@storybook/addon-vitest 10.1.0-alpha.8 → 10.1.0-beta.0

package/dist/node/vitest.js

@@ -1,38 +1,35 @@
-import CJS_COMPAT_NODE_URL_z38dhuq1sk from 'node:url';
-import CJS_COMPAT_NODE_PATH_z38dhuq1sk from 'node:path';
-import CJS_COMPAT_NODE_MODULE_z38dhuq1sk from "node:module";
+import CJS_COMPAT_NODE_URL_2cm23o1mqpi from 'node:url';
+import CJS_COMPAT_NODE_PATH_2cm23o1mqpi from 'node:path';
+import CJS_COMPAT_NODE_MODULE_2cm23o1mqpi from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_z38dhuq1sk.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_z38dhuq1sk.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_z38dhuq1sk.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_2cm23o1mqpi.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_2cm23o1mqpi.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_2cm23o1mqpi.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
   log
-} from "../_node-chunks/chunk-4EU2HFAD.js";
+} from "../_node-chunks/chunk-EDXFFK3M.js";
 import {
-  any,
-  errorToErrorLike
-} from "../_node-chunks/chunk-KKAUWLBT.js";
+  any
+} from "../_node-chunks/chunk-LZHFU3IY.js";
 import {
   ADDON_ID,
   COVERAGE_DIRECTORY,
   STATUS_TYPE_ID_A11Y,
   STATUS_TYPE_ID_COMPONENT_TEST,
   storeOptions
-} from "../_node-chunks/chunk-OYLANTK3.js";
-import "../_node-chunks/chunk-E2BHHDMM.js";
+} from "../_node-chunks/chunk-ERO7LVWY.js";
+import "../_node-chunks/chunk-J7YOLKRX.js";
 import {
   dirname,
   join,
   normalize,
   path
-} from "../_node-chunks/chunk-6S4X4RWE.js";
-import {
-  __name
-} from "../_node-chunks/chunk-QAVSDLTJ.js";
+} from "../_node-chunks/chunk-KJQIXLJD.js";
+import "../_node-chunks/chunk-BGBUUVQU.js";
 
 // src/node/vitest.ts
 import process2 from "node:process";
@@ -45,85 +42,41 @@ import {
 
 // ../../node_modules/es-toolkit/dist/function/debounce.mjs
 function debounce(func, debounceMs, { signal, edges } = {}) {
-  let pendingThis = void 0;
-  let pendingArgs = null;
-  const leading = edges != null && edges.includes("leading");
-  const trailing = edges == null || edges.includes("trailing");
-  const invoke = /* @__PURE__ */ __name(() => {
-    if (pendingArgs !== null) {
-      func.apply(pendingThis, pendingArgs);
-      pendingThis = void 0;
-      pendingArgs = null;
-    }
-  }, "invoke");
-  const onTimerEnd = /* @__PURE__ */ __name(() => {
-    if (trailing) {
-      invoke();
-    }
-    cancel();
-  }, "onTimerEnd");
-  let timeoutId = null;
-  const schedule = /* @__PURE__ */ __name(() => {
-    if (timeoutId != null) {
-      clearTimeout(timeoutId);
-    }
-    timeoutId = setTimeout(() => {
-      timeoutId = null;
-      onTimerEnd();
+  let pendingThis, pendingArgs = null, leading = edges != null && edges.includes("leading"), trailing = edges == null || edges.includes("trailing"), invoke = () => {
+    pendingArgs !== null && (func.apply(pendingThis, pendingArgs), pendingThis = void 0, pendingArgs = null);
+  }, onTimerEnd = () => {
+    trailing && invoke(), cancel();
+  }, timeoutId = null, schedule = () => {
+    timeoutId != null && clearTimeout(timeoutId), timeoutId = setTimeout(() => {
+      timeoutId = null, onTimerEnd();
     }, debounceMs);
-  }, "schedule");
-  const cancelTimer = /* @__PURE__ */ __name(() => {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-  }, "cancelTimer");
-  const cancel = /* @__PURE__ */ __name(() => {
-    cancelTimer();
-    pendingThis = void 0;
-    pendingArgs = null;
-  }, "cancel");
-  const flush = /* @__PURE__ */ __name(() => {
+  }, cancelTimer = () => {
+    timeoutId !== null && (clearTimeout(timeoutId), timeoutId = null);
+  }, cancel = () => {
+    cancelTimer(), pendingThis = void 0, pendingArgs = null;
+  }, flush = () => {
     invoke();
-  }, "flush");
-  const debounced = /* @__PURE__ */ __name(function(...args) {
-    if (signal?.aborted) {
+  }, debounced = function(...args) {
+    if (signal?.aborted)
       return;
-    }
-    pendingThis = this;
-    pendingArgs = args;
-    const isFirstCall = timeoutId == null;
-    schedule();
-    if (leading && isFirstCall) {
-      invoke();
-    }
-  }, "debounced");
-  debounced.schedule = schedule;
-  debounced.cancel = cancel;
-  debounced.flush = flush;
-  signal?.addEventListener("abort", cancel, { once: true });
-  return debounced;
+    pendingThis = this, pendingArgs = args;
+    let isFirstCall = timeoutId == null;
+    schedule(), leading && isFirstCall && invoke();
+  };
+  return debounced.schedule = schedule, debounced.cancel = cancel, debounced.flush = flush, signal?.addEventListener("abort", cancel, { once: !0 }), debounced;
 }
-__name(debounce, "debounce");
 
 // ../../node_modules/es-toolkit/dist/function/partial.mjs
 function partial(func, ...partialArgs) {
   return partialImpl(func, placeholderSymbol, ...partialArgs);
 }
-__name(partial, "partial");
 function partialImpl(func, placeholder, ...partialArgs) {
-  const partialed = /* @__PURE__ */ __name(function(...providedArgs) {
-    let providedArgsIndex = 0;
-    const substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg);
-    const remainingArgs = providedArgs.slice(providedArgsIndex);
+  let partialed = function(...providedArgs) {
+    let providedArgsIndex = 0, substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg), remainingArgs = providedArgs.slice(providedArgsIndex);
     return func.apply(this, substitutedArgs.concat(remainingArgs));
-  }, "partialed");
-  if (func.prototype) {
-    partialed.prototype = Object.create(func.prototype);
-  }
-  return partialed;
+  };
+  return func.prototype && (partialed.prototype = Object.create(func.prototype)), partialed;
 }
-__name(partialImpl, "partialImpl");
 var placeholderSymbol = Symbol("partial.placeholder");
 partial.placeholder = placeholderSymbol;
 
@@ -131,22 +84,13 @@ partial.placeholder = placeholderSymbol;
 function partialRight(func, ...partialArgs) {
   return partialRightImpl(func, placeholderSymbol2, ...partialArgs);
 }
-__name(partialRight, "partialRight");
 function partialRightImpl(func, placeholder, ...partialArgs) {
-  const partialedRight = /* @__PURE__ */ __name(function(...providedArgs) {
-    const placeholderLength = partialArgs.filter((arg) => arg === placeholder).length;
-    const rangeLength = Math.max(providedArgs.length - placeholderLength, 0);
-    const remainingArgs = providedArgs.slice(0, rangeLength);
-    let providedArgsIndex = rangeLength;
-    const substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg);
+  let partialedRight = function(...providedArgs) {
+    let placeholderLength = partialArgs.filter((arg) => arg === placeholder).length, rangeLength = Math.max(providedArgs.length - placeholderLength, 0), remainingArgs = providedArgs.slice(0, rangeLength), providedArgsIndex = rangeLength, substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg);
     return func.apply(this, remainingArgs.concat(substitutedArgs));
-  }, "partialedRight");
-  if (func.prototype) {
-    partialedRight.prototype = Object.create(func.prototype);
-  }
-  return partialedRight;
+  };
+  return func.prototype && (partialedRight.prototype = Object.create(func.prototype)), partialedRight;
 }
-__name(partialRightImpl, "partialRightImpl");
 var placeholderSymbol2 = Symbol("partialRight.placeholder");
 partialRight.placeholder = placeholderSymbol2;
 
@@ -155,24 +99,22 @@ var DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
 
 // ../../node_modules/es-toolkit/dist/function/throttle.mjs
 function throttle(func, throttleMs, { signal, edges = ["leading", "trailing"] } = {}) {
-  let pendingAt = null;
-  const debounced = debounce(func, throttleMs, { signal, edges });
-  const throttled = /* @__PURE__ */ __name(function(...args) {
-    if (pendingAt == null) {
-      pendingAt = Date.now();
-    } else {
-      if (Date.now() - pendingAt >= throttleMs) {
-        pendingAt = Date.now();
-        debounced.cancel();
-      }
-    }
-    debounced(...args);
-  }, "throttled");
-  throttled.cancel = debounced.cancel;
-  throttled.flush = debounced.flush;
-  return throttled;
+  let pendingAt = null, debounced = debounce(func, throttleMs, { signal, edges }), throttled = function(...args) {
+    pendingAt == null ? pendingAt = Date.now() : Date.now() - pendingAt >= throttleMs && (pendingAt = Date.now(), debounced.cancel()), debounced.apply(this, args);
+  };
+  return throttled.cancel = debounced.cancel, throttled.flush = debounced.flush, throttled;
+}
+
+// src/utils.ts
+function errorToErrorLike(error) {
+  return {
+    message: error.message,
+    name: error.name,
+    // avoid duplicating the error message in the stack trace
+    stack: error.stack?.replace(error.message, ""),
+    cause: error.cause && error.cause instanceof Error ? errorToErrorLike(error.cause) : void 0
+  };
 }
-__name(throttle, "throttle");
 
 // src/node/vitest-manager.ts
 import { existsSync } from "node:fs";
@@ -180,28 +122,19 @@ import { getProjectRoot, resolvePathInStorybookCache } from "storybook/internal/
 
 // ../../node_modules/slash/index.js
 function slash(path2) {
-  const isExtendedLengthPath = path2.startsWith("\\\\?\\");
-  if (isExtendedLengthPath) {
-    return path2;
-  }
-  return path2.replace(/\\/g, "/");
+  return path2.startsWith("\\\\?\\") ? path2 : path2.replace(/\\/g, "/");
 }
-__name(slash, "slash");
 
 // src/node/reporter.ts
 var StorybookReporter = class {
   constructor(testManager) {
     this.testManager = testManager;
   }
-  static {
-    __name(this, "StorybookReporter");
-  }
   onInit(ctx) {
     this.ctx = ctx;
   }
   onTestCaseResult(testCase) {
-    const { storyId, reports } = testCase.meta();
-    const testResult = testCase.result();
+    let { storyId, reports } = testCase.meta(), testResult = testCase.result();
     this.testManager.onTestCaseResult({
       storyId,
       testResult,
@@ -209,42 +142,30 @@ var StorybookReporter = class {
     });
   }
   async onTestRunEnd(testModules, unhandledErrors) {
-    const totalTestCount = testModules.flatMap(
+    let totalTestCount = testModules.flatMap(
       (t) => Array.from(t.children.allTests("passed")).concat(Array.from(t.children.allTests("failed")))
-    ).length;
-    const testModulesErrors = testModules.flatMap((t) => t.errors());
-    const serializedErrors = unhandledErrors.concat(testModulesErrors).map((e) => {
-      return {
-        ...e,
-        name: e.name,
-        message: e.message,
-        stack: e.stack?.replace(e.message, ""),
-        cause: e.cause
-      };
-    });
+    ).length, testModulesErrors = testModules.flatMap((t) => t.errors()), serializedErrors = unhandledErrors.concat(testModulesErrors).map((e) => ({
+      ...e,
+      name: e.name,
+      message: e.message,
+      stack: e.stack?.replace(e.message, ""),
+      cause: e.cause
+    }));
     this.testManager.onTestRunEnd({
       totalTestCount,
       unhandledErrors: serializedErrors
-    });
-    this.clearVitestState();
+    }), this.clearVitestState();
   }
   // TODO: Clearing the whole internal state of Vitest might be too aggressive
   async clearVitestState() {
-    this.ctx.state.filesMap.clear();
-    this.ctx.state.pathsSet.clear();
-    this.ctx.state.idMap.clear();
-    this.ctx.state.errorsSet.clear();
-    this.ctx.state.processTimeoutCauses?.clear();
+    this.ctx.state.filesMap.clear(), this.ctx.state.pathsSet.clear(), this.ctx.state.idMap.clear(), this.ctx.state.errorsSet.clear(), this.ctx.state.processTimeoutCauses?.clear();
   }
 };
 
 // src/node/vitest-manager.ts
-var VITEST_CONFIG_FILE_EXTENSIONS = ["mts", "mjs", "cts", "cjs", "ts", "tsx", "js", "jsx"];
-var VITEST_WORKSPACE_FILE_EXTENSION = ["ts", "js", "json"];
+var VITEST_CONFIG_FILE_EXTENSIONS = ["mts", "mjs", "cts", "cjs", "ts", "tsx", "js", "jsx"], VITEST_WORKSPACE_FILE_EXTENSION = ["ts", "js", "json"];
 process.env.VITEST_STORYBOOK = "true";
-var DOUBLE_SPACES = "  ";
-var getTestName = /* @__PURE__ */ __name((name) => `${name}${DOUBLE_SPACES}`, "getTestName");
-var VitestManager = class {
+var DOUBLE_SPACES = "  ", getTestName = (name) => `${name}${DOUBLE_SPACES}`, VitestManager = class {
   constructor(testManager) {
     this.testManager = testManager;
     this.vitest = null;
@@ -252,39 +173,32 @@ var VitestManager = class {
     this.vitestRestartPromise = null;
     this.runningPromise = null;
   }
-  static {
-    __name(this, "VitestManager");
-  }
   async startVitest({ coverage }) {
-    const { createVitest } = await import("vitest/node");
-    const storybookCoverageReporter = [
+    let { createVitest } = await import("vitest/node"), storybookCoverageReporter = [
       "@storybook/addon-vitest/internal/coverage-reporter",
       {
         testManager: this.testManager,
         coverageOptions: this.vitest?.config?.coverage
       }
-    ];
-    const coverageOptions = coverage ? {
-      enabled: true,
-      clean: true,
-      cleanOnRerun: true,
-      reportOnFailure: true,
+    ], coverageOptions = coverage ? {
+      enabled: !0,
+      clean: !0,
+      cleanOnRerun: !0,
+      reportOnFailure: !0,
       reporter: [["html", {}], storybookCoverageReporter],
       reportsDirectory: resolvePathInStorybookCache(COVERAGE_DIRECTORY)
-    } : { enabled: false };
-    const vitestWorkspaceConfig = any(
+    } : { enabled: !1 }, vitestWorkspaceConfig = any(
       [
         ...VITEST_WORKSPACE_FILE_EXTENSION.map((ext) => `vitest.workspace.${ext}`),
         ...VITEST_CONFIG_FILE_EXTENSIONS.map((ext) => `vitest.config.${ext}`)
       ],
       { last: getProjectRoot() }
-    );
-    const projectName = "storybook:" + process.env.STORYBOOK_CONFIG_DIR;
+    ), projectName = "storybook:" + process.env.STORYBOOK_CONFIG_DIR;
     try {
       this.vitest = await createVitest("test", {
         root: vitestWorkspaceConfig ? dirname(vitestWorkspaceConfig) : process.cwd(),
-        watch: true,
-        passWithNoTests: false,
+        watch: !0,
+        passWithNoTests: !1,
         project: [projectName],
         // TODO:
         // Do we want to enable Vite's default reporter?
@@ -295,176 +209,104 @@ var VitestManager = class {
         coverage: coverageOptions
       });
     } catch (err) {
-      const originalMessage = String(err.message);
+      let originalMessage = String(err.message);
       if (originalMessage.includes("Found multiple projects")) {
-        const custom = [
+        let custom = [
           "Storybook was unable to start the test run because you have multiple Vitest projects (or browsers) in headed mode.",
           "Please set `headless: true` in your Storybook vitest config.\n\n"
-        ].join("\n");
-        if (!originalMessage.startsWith(custom)) {
-          err.message = `${custom}${originalMessage}`;
-        }
+        ].join(`
+`);
+        originalMessage.startsWith(custom) || (err.message = `${custom}${originalMessage}`);
       }
       throw err;
     }
-    if (this.vitest) {
-      this.vitest.onCancel(() => {
-      });
-    }
+    this.vitest && this.vitest.onCancel(() => {
+    });
     try {
       await this.vitest.init();
     } catch (e) {
-      let message = "Failed to initialize Vitest";
-      const isV8 = e.message?.includes("@vitest/coverage-v8");
-      const isIstanbul = e.message?.includes("@vitest/coverage-istanbul");
-      if (e.message?.includes("Failed to load url") && (isIstanbul || isV8) || // Vitest will sometimes not throw the correct missing-package-detection error, so we have to check for this as well
-      e instanceof TypeError && e?.message === "Cannot read properties of undefined (reading 'name')") {
-        const coveragePackage = isIstanbul ? "coverage-istanbul" : "coverage-v8";
-        message += `
+      let message = "Failed to initialize Vitest", isV8 = e.message?.includes("@vitest/coverage-v8"), isIstanbul = e.message?.includes("@vitest/coverage-istanbul");
+      (e.message?.includes("Failed to load url") && (isIstanbul || isV8) || // Vitest will sometimes not throw the correct missing-package-detection error, so we have to check for this as well
+      e instanceof TypeError && e?.message === "Cannot read properties of undefined (reading 'name')") && (message += `
 
-Please install the @vitest/${coveragePackage} package to collect coverage
-`;
-      }
-      this.testManager.reportFatalError(message, e);
+Please install the @vitest/${isIstanbul ? "coverage-istanbul" : "coverage-v8"} package to collect coverage
+`), this.testManager.reportFatalError(message, e);
       return;
     }
     await this.setupWatchers();
   }
   async restartVitest({ coverage }) {
-    await this.vitestRestartPromise;
-    this.vitestRestartPromise = new Promise(async (resolve, reject) => {
+    return await this.vitestRestartPromise, this.vitestRestartPromise = new Promise(async (resolve, reject) => {
       try {
-        await this.runningPromise;
-        await this.vitest?.close();
-        await this.startVitest({ coverage });
-        resolve();
+        await this.runningPromise, await this.vitest?.close(), await this.startVitest({ coverage }), resolve();
       } catch (e) {
         reject(e);
       } finally {
         this.vitestRestartPromise = null;
       }
-    });
-    return this.vitestRestartPromise;
+    }), this.vitestRestartPromise;
   }
   resetGlobalTestNamePattern() {
     this.vitest?.setGlobalTestNamePattern("");
   }
   updateLastChanged(filepath) {
     this.vitest.projects.forEach(({ browser, vite, server }) => {
-      if (server) {
-        const serverMods = server.moduleGraph.getModulesByFile(filepath);
-        serverMods?.forEach((mod) => server.moduleGraph.invalidateModule(mod));
-      }
-      if (vite) {
-        const serverMods = vite.moduleGraph.getModulesByFile(filepath);
-        serverMods?.forEach((mod) => vite.moduleGraph.invalidateModule(mod));
-      }
-      if (browser) {
-        const browserMods = browser.vite.moduleGraph.getModulesByFile(filepath);
-        browserMods?.forEach((mod) => browser.vite.moduleGraph.invalidateModule(mod));
-      }
+      server && server.moduleGraph.getModulesByFile(filepath)?.forEach((mod) => server.moduleGraph.invalidateModule(mod)), vite && vite.moduleGraph.getModulesByFile(filepath)?.forEach((mod) => vite.moduleGraph.invalidateModule(mod)), browser && browser.vite.moduleGraph.getModulesByFile(filepath)?.forEach((mod) => browser.vite.moduleGraph.invalidateModule(mod));
     });
   }
   async fetchStories(requestStoryIds) {
-    const indexUrl = this.testManager.store.getState().indexUrl;
-    if (!indexUrl) {
+    let indexUrl = this.testManager.store.getState().indexUrl;
+    if (!indexUrl)
       throw new Error(
         "Tried to fetch stories to test, but the index URL was not set in the store yet."
       );
-    }
     try {
-      const index = await Promise.race([
+      let index = await Promise.race([
         fetch(indexUrl).then((res) => res.json()),
         new Promise((_, reject) => setTimeout(reject, 3e3, new Error("Request took too long")))
       ]);
-      const storyIds = requestStoryIds || Object.keys(index.entries);
-      return storyIds.map((id) => index.entries[id]).filter((story) => story.type === "story");
+      return (requestStoryIds || Object.keys(index.entries)).map((id) => index.entries[id]).filter((story) => story.type === "story");
     } catch (e) {
-      log("Failed to fetch story index: " + e.message);
-      return [];
+      return log("Failed to fetch story index: " + e.message), [];
     }
   }
   filterTestSpecifications(testSpecifications, stories) {
-    const filteredTestSpecifications = [];
-    const filteredStoryIds = [];
-    const storiesByImportPath = {};
-    for (const story of stories) {
-      const absoluteImportPath = path.join(process.cwd(), story.importPath);
-      if (!storiesByImportPath[absoluteImportPath]) {
-        storiesByImportPath[absoluteImportPath] = [];
-      }
-      storiesByImportPath[absoluteImportPath].push(story);
+    let filteredTestSpecifications = [], filteredStoryIds = [], storiesByImportPath = {};
+    for (let story of stories) {
+      let absoluteImportPath = path.join(process.cwd(), story.importPath);
+      storiesByImportPath[absoluteImportPath] || (storiesByImportPath[absoluteImportPath] = []), storiesByImportPath[absoluteImportPath].push(story);
     }
-    for (const testSpecification of testSpecifications) {
-      const { env = {} } = testSpecification.project.config;
-      const include = env.__VITEST_INCLUDE_TAGS__?.split(",").filter(Boolean) ?? ["test"];
-      const exclude = env.__VITEST_EXCLUDE_TAGS__?.split(",").filter(Boolean) ?? [];
-      const skip = env.__VITEST_SKIP_TAGS__?.split(",").filter(Boolean) ?? [];
-      const storiesInTestSpecification = storiesByImportPath[testSpecification.moduleId] ?? [];
-      const filteredStories = storiesInTestSpecification.filter((story) => {
-        if (include.length && !include.some((tag) => story.tags?.includes(tag))) {
-          return false;
-        }
-        if (exclude.some((tag) => story.tags?.includes(tag))) {
-          return false;
-        }
-        return true;
-      });
-      if (!filteredStories.length) {
-        continue;
-      }
-      if (!this.testManager.store.getState().watching) {
-        this.updateLastChanged(testSpecification.moduleId);
-      }
-      filteredTestSpecifications.push(testSpecification);
-      filteredStoryIds.push(
+    for (let testSpecification of testSpecifications) {
+      let { env = {} } = testSpecification.project.config, include = env.__VITEST_INCLUDE_TAGS__?.split(",").filter(Boolean) ?? ["test"], exclude = env.__VITEST_EXCLUDE_TAGS__?.split(",").filter(Boolean) ?? [], skip = env.__VITEST_SKIP_TAGS__?.split(",").filter(Boolean) ?? [], filteredStories = (storiesByImportPath[testSpecification.moduleId] ?? []).filter((story) => !(include.length && !include.some((tag) => story.tags?.includes(tag)) || exclude.some((tag) => story.tags?.includes(tag))));
+      filteredStories.length && (this.testManager.store.getState().watching || this.updateLastChanged(testSpecification.moduleId), filteredTestSpecifications.push(testSpecification), filteredStoryIds.push(
         ...filteredStories.filter((story) => !skip.some((tag) => story.tags?.includes(tag))).map((story) => story.id)
-      );
+      ));
     }
     return { filteredTestSpecifications, filteredStoryIds };
   }
   async runTests(runPayload) {
-    const { watching, config } = this.testManager.store.getState();
-    const coverageShouldBeEnabled = config.coverage && !watching && (runPayload?.storyIds?.length ?? 0) === 0;
-    const currentCoverage = this.vitest?.config.coverage?.enabled;
-    if (!this.vitest) {
-      await this.startVitest({ coverage: coverageShouldBeEnabled });
-    } else if (currentCoverage !== coverageShouldBeEnabled) {
-      await this.restartVitest({ coverage: coverageShouldBeEnabled });
-    } else {
-      await this.vitestRestartPromise;
-    }
-    this.resetGlobalTestNamePattern();
-    await this.cancelCurrentRun();
-    const testSpecifications = await this.getStorybookTestSpecifications();
-    const allStories = await this.fetchStories();
-    const filteredStories = runPayload.storyIds ? allStories.filter((story) => runPayload.storyIds?.includes(story.id)) : allStories;
-    const isSingleStoryRun = runPayload.storyIds?.length === 1;
-    if (isSingleStoryRun) {
-      const selectedStory = filteredStories.find((story) => story.id === runPayload.storyIds?.[0]);
-      if (!selectedStory) {
+    let { watching, config } = this.testManager.store.getState(), coverageShouldBeEnabled = config.coverage && !watching && (runPayload?.storyIds?.length ?? 0) === 0, currentCoverage = this.vitest?.config.coverage?.enabled;
+    this.vitest ? currentCoverage !== coverageShouldBeEnabled ? await this.restartVitest({ coverage: coverageShouldBeEnabled }) : await this.vitestRestartPromise : await this.startVitest({ coverage: coverageShouldBeEnabled }), this.resetGlobalTestNamePattern(), await this.cancelCurrentRun();
+    let testSpecifications = await this.getStorybookTestSpecifications(), allStories = await this.fetchStories(), filteredStories = runPayload.storyIds ? allStories.filter((story) => runPayload.storyIds?.includes(story.id)) : allStories;
+    if (runPayload.storyIds?.length === 1) {
+      let selectedStory = filteredStories.find((story) => story.id === runPayload.storyIds?.[0]);
+      if (!selectedStory)
         throw new Error(`Story ${runPayload.storyIds?.[0]} not found`);
-      }
-      const storyName = selectedStory.name;
-      let regex;
-      const isParentStory = allStories.some((story) => selectedStory.id === story.parent);
-      const hasParentStory = allStories.some((story) => selectedStory.parent === story.id);
+      let storyName = selectedStory.name, regex, isParentStory = allStories.some((story) => selectedStory.id === story.parent), hasParentStory = allStories.some((story) => selectedStory.parent === story.id);
       if (isParentStory) {
-        const parentName = getTestName(selectedStory.name);
+        let parentName = getTestName(selectedStory.name);
         regex = new RegExp(`^${parentName}`);
       } else if (hasParentStory) {
-        const parentStory = allStories.find((story) => story.id === selectedStory.parent);
-        if (!parentStory) {
+        let parentStory = allStories.find((story) => story.id === selectedStory.parent);
+        if (!parentStory)
           throw new Error(`Parent story not found for story ${selectedStory.id}`);
-        }
-        const parentName = getTestName(parentStory.name);
+        let parentName = getTestName(parentStory.name);
         regex = new RegExp(`^${parentName} ${storyName}$`);
-      } else {
+      } else
         regex = new RegExp(`^${storyName}$`);
-      }
       this.vitest.setGlobalTestNamePattern(regex);
     }
-    const { filteredTestSpecifications, filteredStoryIds } = this.filterTestSpecifications(
+    let { filteredTestSpecifications, filteredStoryIds } = this.filterTestSpecifications(
       testSpecifications,
       filteredStories
     );
@@ -474,138 +316,92 @@ Please install the @vitest/${coveragePackage} package to collect coverage
         ...s.currentRun,
         totalTestCount: filteredStoryIds.length
       }
-    }));
-    await this.vitest.runTestSpecifications(filteredTestSpecifications, true);
-    this.resetGlobalTestNamePattern();
+    })), await this.vitest.runTestSpecifications(filteredTestSpecifications, !0), this.resetGlobalTestNamePattern();
   }
   async cancelCurrentRun() {
-    await this.vitest?.cancelCurrentRun("keyboard-input");
-    await this.runningPromise;
+    await this.vitest?.cancelCurrentRun("keyboard-input"), await this.runningPromise;
   }
   async getStorybookTestSpecifications() {
-    const globTestSpecifications = await this.vitest?.globTestSpecifications() ?? [];
-    return globTestSpecifications.filter(
+    return (await this.vitest?.globTestSpecifications() ?? []).filter(
       (workspaceSpec) => this.isStorybookProject(workspaceSpec.project)
     ) ?? [];
   }
   async runAffectedTestsAfterChange(changedFilePath, event) {
-    const id = slash(changedFilePath);
-    this.vitest?.logger.clearHighlightCache(id);
-    this.updateLastChanged(id);
-    if (event === "add") {
-      const project = this.vitest?.projects.find(this.isStorybookProject.bind(this));
-      project?.matchesTestGlob(id);
-    }
-    if (!this.testManager.store.getState().watching) {
-      return;
-    }
-    if (!this.vitest) {
+    let id = slash(changedFilePath);
+    if (this.vitest?.logger.clearHighlightCache(id), this.updateLastChanged(id), event === "add" && this.vitest?.projects.find(this.isStorybookProject.bind(this))?.matchesTestGlob(id), !this.testManager.store.getState().watching || !this.vitest)
       return;
-    }
     this.resetGlobalTestNamePattern();
-    const storybookProject = this.vitest.projects.find((p) => this.isStorybookProject(p));
-    const previewAnnotationSpecifications = this.testManager.store.getState().previewAnnotations.map((previewAnnotation) => {
-      return {
-        project: storybookProject ?? this.vitest.projects[0],
-        moduleId: typeof previewAnnotation === "string" ? previewAnnotation : previewAnnotation.absolute
-      };
-    });
-    const setupFilesSpecifications = this.vitest.projects.flatMap(
+    let storybookProject = this.vitest.projects.find((p) => this.isStorybookProject(p)), previewAnnotationSpecifications = this.testManager.store.getState().previewAnnotations.map((previewAnnotation) => ({
+      project: storybookProject ?? this.vitest.projects[0],
+      moduleId: typeof previewAnnotation == "string" ? previewAnnotation : previewAnnotation.absolute
+    })), setupFilesSpecifications = this.vitest.projects.flatMap(
       (project) => project.config.setupFiles.map((setupFile) => ({
         project,
         moduleId: setupFile
       }))
-    );
-    const syntheticGlobalTestSpecifications = previewAnnotationSpecifications.concat(setupFilesSpecifications);
-    const testSpecifications = await this.getStorybookTestSpecifications();
-    const allStories = await this.fetchStories();
-    let affectsGlobalFiles = false;
-    const affectedTestSpecifications = (await Promise.all(
+    ), syntheticGlobalTestSpecifications = previewAnnotationSpecifications.concat(setupFilesSpecifications), testSpecifications = await this.getStorybookTestSpecifications(), allStories = await this.fetchStories(), affectsGlobalFiles = !1, affectedTestSpecifications = (await Promise.all(
       syntheticGlobalTestSpecifications.concat(testSpecifications).map(async (testSpecification) => {
-        const dependencies = await this.getTestDependencies(testSpecification);
-        if (changedFilePath === testSpecification.moduleId || dependencies.has(changedFilePath)) {
-          if (syntheticGlobalTestSpecifications.includes(testSpecification)) {
-            affectsGlobalFiles = true;
-          }
-          return testSpecification;
-        }
+        let dependencies = await this.getTestDependencies(testSpecification);
+        if (changedFilePath === testSpecification.moduleId || dependencies.has(changedFilePath))
+          return syntheticGlobalTestSpecifications.includes(testSpecification) && (affectsGlobalFiles = !0), testSpecification;
       })
-    )).filter(Boolean);
-    const testSpecificationsToRun = affectsGlobalFiles ? testSpecifications : affectedTestSpecifications;
-    if (!testSpecificationsToRun.length) {
+    )).filter(Boolean), testSpecificationsToRun = affectsGlobalFiles ? testSpecifications : affectedTestSpecifications;
+    if (!testSpecificationsToRun.length)
       return;
-    }
-    const { filteredTestSpecifications, filteredStoryIds } = this.filterTestSpecifications(
+    let { filteredTestSpecifications, filteredStoryIds } = this.filterTestSpecifications(
       testSpecificationsToRun,
       allStories
     );
     await this.testManager.runTestsWithState({
       storyIds: filteredStoryIds,
       triggeredBy: "watch",
-      callback: /* @__PURE__ */ __name(async () => {
+      callback: async () => {
         this.testManager.store.setState((s) => ({
           ...s,
           currentRun: {
             ...s.currentRun,
             totalTestCount: filteredStoryIds.length
           }
-        }));
-        await this.vitest.cancelCurrentRun("keyboard-input");
-        await this.runningPromise;
-        await this.vitest.runTestSpecifications(filteredTestSpecifications, false);
-      }, "callback")
+        })), await this.vitest.cancelCurrentRun("keyboard-input"), await this.runningPromise, await this.vitest.runTestSpecifications(filteredTestSpecifications, !1);
+      }
     });
   }
   // This is an adaptation of Vitest's own implementation
   // see https://github.com/vitest-dev/vitest/blob/14409088166152c920ce7fa4ad4c0ba57149b869/packages/vitest/src/node/specifications.ts#L171-L198
   async getTestDependencies(spec) {
-    const deps = /* @__PURE__ */ new Set();
-    const addImports = /* @__PURE__ */ __name(async (project, filepath) => {
-      if (deps.has(filepath)) {
+    let deps = /* @__PURE__ */ new Set(), addImports = async (project, filepath) => {
+      if (deps.has(filepath))
         return;
-      }
       deps.add(filepath);
-      const mod = project.vite.moduleGraph.getModuleById(filepath);
-      const transformed = mod?.ssrTransformResult || await project.vite.transformRequest(filepath, { ssr: true });
-      if (!transformed) {
+      let transformed = project.vite.moduleGraph.getModuleById(filepath)?.ssrTransformResult || await project.vite.transformRequest(filepath, { ssr: !0 });
+      if (!transformed)
         return;
-      }
-      const dependencies = [...transformed.deps ?? [], ...transformed.dynamicDeps ?? []];
+      let dependencies = [...transformed.deps ?? [], ...transformed.dynamicDeps ?? []];
       await Promise.all(
         dependencies.map(async (dep) => {
-          const fsPath = dep.startsWith("/@fs/") ? dep.slice(process.platform === "win32" ? 5 : 4) : join(project.config.root, dep);
-          if (!fsPath.includes("node_modules") && !deps.has(fsPath) && existsSync(fsPath)) {
-            await addImports(project, fsPath);
-          }
+          let fsPath = dep.startsWith("/@fs/") ? dep.slice(process.platform === "win32" ? 5 : 4) : join(project.config.root, dep);
+          !fsPath.includes("node_modules") && !deps.has(fsPath) && existsSync(fsPath) && await addImports(project, fsPath);
         })
       );
-    }, "addImports");
-    await addImports(spec.project, spec.moduleId);
-    deps.delete(spec.moduleId);
-    return deps;
+    };
+    return await addImports(spec.project, spec.moduleId), deps.delete(spec.moduleId), deps;
   }
   async registerVitestConfigListener() {
     this.vitest.vite.watcher.on("change", async (file) => {
-      const isConfig = normalize(file) === this.vitest?.vite?.config.configFile;
-      if (isConfig) {
+      if (normalize(file) === this.vitest?.vite?.config.configFile) {
         log("Restarting Vitest due to config change");
-        const { watching, config } = this.testManager.store.getState();
+        let { watching, config } = this.testManager.store.getState();
         await this.restartVitest({ coverage: config.coverage && !watching });
       }
     });
   }
   async setupWatchers() {
-    this.resetGlobalTestNamePattern();
-    this.vitest.vite.watcher.removeAllListeners("change");
-    this.vitest.vite.watcher.removeAllListeners("add");
-    this.vitest.vite.watcher.on(
+    this.resetGlobalTestNamePattern(), this.vitest.vite.watcher.removeAllListeners("change"), this.vitest.vite.watcher.removeAllListeners("add"), this.vitest.vite.watcher.on(
       "change",
       (file) => this.runAffectedTestsAfterChange(file, "change")
-    );
-    this.vitest.vite.watcher.on("add", (file) => {
+    ), this.vitest.vite.watcher.on("add", (file) => {
       this.runAffectedTestsAfterChange(file, "add");
-    });
-    this.registerVitestConfigListener();
+    }), this.registerVitestConfigListener();
   }
   isStorybookProject(project) {
     return !!project.config.env?.__STORYBOOK_URL__;
@@ -619,8 +415,7 @@ var testStateToStatusValueMap = {
   warning: "status-value:warning",
   failed: "status-value:error",
   skipped: "status-value:unknown"
-};
-var TestManager = class _TestManager {
+}, TestManager = class _TestManager {
   constructor(options) {
     this.batchedTestCaseResults = [];
     /**
@@ -638,28 +433,15 @@ var TestManager = class _TestManager {
      * eventually causing the manager and dev server to lose connection.
      */
     this.throttledFlushTestCaseResults = throttle(() => {
-      const testCaseResultsToFlush = this.batchedTestCaseResults;
-      this.batchedTestCaseResults = [];
-      this.store.setState((s) => {
-        let { success: ctSuccess, error: ctError } = s.currentRun.componentTestCount;
-        let { success: a11ySuccess, warning: a11yWarning, error: a11yError } = s.currentRun.a11yCount;
+      let testCaseResultsToFlush = this.batchedTestCaseResults;
+      this.batchedTestCaseResults = [], this.store.setState((s) => {
+        let { success: ctSuccess, error: ctError } = s.currentRun.componentTestCount, { success: a11ySuccess, warning: a11yWarning, error: a11yError } = s.currentRun.a11yCount;
         testCaseResultsToFlush.forEach(({ testResult, reports }) => {
-          if (testResult.state === "passed") {
-            ctSuccess++;
-          } else if (testResult.state === "failed") {
-            ctError++;
-          }
-          reports?.filter((r) => r.type === "a11y").forEach((report) => {
-            if (report.status === "passed") {
-              a11ySuccess++;
-            } else if (report.status === "warning") {
-              a11yWarning++;
-            } else if (report.status === "failed") {
-              a11yError++;
-            }
+          testResult.state === "passed" ? ctSuccess++ : testResult.state === "failed" && ctError++, reports?.filter((r) => r.type === "a11y").forEach((report) => {
+            report.status === "passed" ? a11ySuccess++ : report.status === "warning" ? a11yWarning++ : report.status === "failed" && a11yError++;
           });
         });
-        const finishedTestCount = ctSuccess + ctError;
+        let finishedTestCount = ctSuccess + ctError;
         return {
           ...s,
           currentRun: {
@@ -673,75 +455,57 @@ var TestManager = class _TestManager {
           }
         };
       });
-      const componentTestStatuses = testCaseResultsToFlush.map(({ storyId, testResult }) => ({
+      let componentTestStatuses = testCaseResultsToFlush.map(({ storyId, testResult }) => ({
         storyId,
         typeId: STATUS_TYPE_ID_COMPONENT_TEST,
         value: testStateToStatusValueMap[testResult.state],
         title: "Component tests",
-        description: testResult.errors?.map((error) => error.stack || error.message).join("\n") ?? "",
-        sidebarContextMenu: false
+        description: testResult.errors?.map((error) => error.stack || error.message).join(`
+`) ?? "",
+        sidebarContextMenu: !1
       }));
       this.componentTestStatusStore.set(componentTestStatuses);
-      const a11yStatuses = testCaseResultsToFlush.flatMap(
+      let a11yStatuses = testCaseResultsToFlush.flatMap(
         ({ storyId, reports }) => reports?.filter((r) => r.type === "a11y").map((a11yReport) => ({
           storyId,
           typeId: STATUS_TYPE_ID_A11Y,
           value: testStateToStatusValueMap[a11yReport.status],
           title: "Accessibility tests",
           description: "",
-          sidebarContextMenu: false
+          sidebarContextMenu: !1
         }))
       ).filter((a11yStatus) => a11yStatus !== void 0);
-      if (a11yStatuses.length > 0) {
-        this.a11yStatusStore.set(a11yStatuses);
-      }
+      a11yStatuses.length > 0 && this.a11yStatusStore.set(a11yStatuses);
     }, 500);
-    this.store = options.store;
-    this.componentTestStatusStore = options.componentTestStatusStore;
-    this.a11yStatusStore = options.a11yStatusStore;
-    this.testProviderStore = options.testProviderStore;
-    this.onReady = options.onReady;
-    this.storybookOptions = options.storybookOptions;
-    this.vitestManager = new VitestManager(this);
-    this.store.subscribe("TRIGGER_RUN", this.handleTriggerRunEvent.bind(this));
-    this.store.subscribe("CANCEL_RUN", this.handleCancelEvent.bind(this));
-    this.store.untilReady().then(() => {
-      return this.vitestManager.startVitest({ coverage: this.store.getState().config.coverage });
-    }).then(() => this.onReady?.()).catch((e) => {
+    this.store = options.store, this.componentTestStatusStore = options.componentTestStatusStore, this.a11yStatusStore = options.a11yStatusStore, this.testProviderStore = options.testProviderStore, this.onReady = options.onReady, this.storybookOptions = options.storybookOptions, this.vitestManager = new VitestManager(this), this.store.subscribe("TRIGGER_RUN", this.handleTriggerRunEvent.bind(this)), this.store.subscribe("CANCEL_RUN", this.handleCancelEvent.bind(this)), this.store.untilReady().then(() => this.vitestManager.startVitest({ coverage: this.store.getState().config.coverage })).then(() => this.onReady?.()).catch((e) => {
       this.reportFatalError("Failed to start Vitest", e);
     });
   }
-  static {
-    __name(this, "TestManager");
-  }
   async handleTriggerRunEvent(event) {
     await this.runTestsWithState({
       storyIds: event.payload.storyIds,
       triggeredBy: event.payload.triggeredBy,
-      callback: /* @__PURE__ */ __name(async () => {
+      callback: async () => {
         try {
-          await this.vitestManager.vitestRestartPromise;
-          await this.vitestManager.runTests(event.payload);
+          await this.vitestManager.vitestRestartPromise, await this.vitestManager.runTests(event.payload);
         } catch (err) {
-          this.reportFatalError("Failed to run tests", err);
-          throw err;
+          throw this.reportFatalError("Failed to run tests", err), err;
         }
-      }, "callback")
+      }
     });
   }
   async handleCancelEvent() {
     try {
       this.store.setState((s) => ({
         ...s,
-        cancelling: true
-      }));
-      await this.vitestManager.cancelCurrentRun();
+        cancelling: !0
+      })), await this.vitestManager.cancelCurrentRun();
     } catch (err) {
       this.reportFatalError("Failed to cancel tests", err);
     } finally {
       this.store.setState((s) => ({
         ...s,
-        cancelling: false
+        cancelling: !1
       }));
     }
   }
@@ -750,9 +514,7 @@ var TestManager = class _TestManager {
     triggeredBy,
     callback
   }) {
-    this.componentTestStatusStore.unset(storyIds);
-    this.a11yStatusStore.unset(storyIds);
-    this.store.setState((s) => ({
+    this.componentTestStatusStore.unset(storyIds), this.a11yStatusStore.unset(storyIds), this.store.setState((s) => ({
       ...s,
       currentRun: {
         ...storeOptions.initialState.currentRun,
@@ -761,17 +523,12 @@ var TestManager = class _TestManager {
         storyIds,
         config: s.config
       }
-    }));
-    process.env.VITEST_STORYBOOK_CONFIG = JSON.stringify(this.store.getState().config);
-    await this.testProviderStore.runWithState(async () => {
-      await callback();
-      this.store.send({
+    })), process.env.VITEST_STORYBOOK_CONFIG = JSON.stringify(this.store.getState().config), await this.testProviderStore.runWithState(async () => {
+      if (await callback(), this.store.send({
         type: "TEST_RUN_COMPLETED",
         payload: this.store.getState().currentRun
-      });
-      if (this.store.getState().currentRun.unhandledErrors.length > 0) {
+      }), this.store.getState().currentRun.unhandledErrors.length > 0)
         throw new Error("Tests completed but there are unhandled errors");
-      }
     });
   }
   onTestModuleCollected(collectedTestCount) {
@@ -784,16 +541,11 @@ var TestManager = class _TestManager {
     }));
   }
   onTestCaseResult(result) {
-    const { storyId, testResult, reports } = result;
-    if (!storyId) {
-      return;
-    }
-    this.batchedTestCaseResults.push({ storyId, testResult, reports });
-    this.throttledFlushTestCaseResults();
+    let { storyId, testResult, reports } = result;
+    storyId && (this.batchedTestCaseResults.push({ storyId, testResult, reports }), this.throttledFlushTestCaseResults());
   }
   onTestRunEnd(endResult) {
-    this.throttledFlushTestCaseResults.flush();
-    this.store.setState((s) => ({
+    this.throttledFlushTestCaseResults.flush(), this.store.setState((s) => ({
       ...s,
       currentRun: {
         ...s.currentRun,
@@ -813,8 +565,7 @@ var TestManager = class _TestManager {
     }));
   }
   async reportFatalError(message, error) {
-    await this.store.untilReady();
-    this.store.send({
+    await this.store.untilReady(), this.store.send({
       type: "FATAL_ERROR",
       payload: {
         message,
@@ -824,30 +575,26 @@ var TestManager = class _TestManager {
   }
   static async start(options) {
     return new Promise((resolve) => {
-      const testManager = new _TestManager({
+      let testManager = new _TestManager({
         ...options,
-        onReady: /* @__PURE__ */ __name(() => {
-          resolve(testManager);
-          options.onReady?.();
-        }, "onReady")
+        onReady: () => {
+          resolve(testManager), options.onReady?.();
+        }
       });
     });
   }
 };
 
 // src/node/vitest.ts
-var UniversalStore = experimental_UniversalStore;
-var getStatusStore = experimental_getStatusStore;
-var getTestProviderStore = experimental_getTestProviderStore;
-var channel = new Channel({
-  async: true,
+var UniversalStore = experimental_UniversalStore, getStatusStore = experimental_getStatusStore, getTestProviderStore = experimental_getTestProviderStore, channel = new Channel({
+  async: !0,
   transport: {
-    send: /* @__PURE__ */ __name((event) => {
+    send: (event) => {
       process2.send?.(event);
-    }, "send"),
-    setHandler: /* @__PURE__ */ __name((handler) => {
+    },
+    setHandler: (handler) => {
       process2.on("message", handler);
-    }, "setHandler")
+    }
   }
 });
 UniversalStore.__prepare(channel, UniversalStore.Environment.SERVER);
@@ -857,20 +604,18 @@ new TestManager({
   componentTestStatusStore: getStatusStore(STATUS_TYPE_ID_COMPONENT_TEST),
   a11yStatusStore: getStatusStore(STATUS_TYPE_ID_A11Y),
   testProviderStore: getTestProviderStore(ADDON_ID),
-  onReady: /* @__PURE__ */ __name(() => {
+  onReady: () => {
     process2.send?.({ type: "ready" });
-  }, "onReady"),
+  },
   storybookOptions: {
     configDir: process2.env.STORYBOOK_CONFIG_DIR || ""
   }
 });
-var exit = /* @__PURE__ */ __name((code = 0) => {
-  channel?.removeAllListeners();
-  process2.exit(code);
-}, "exit");
-var createUnhandledErrorHandler = /* @__PURE__ */ __name((message) => async (error) => {
+var exit = (code = 0) => {
+  channel?.removeAllListeners(), process2.exit(code);
+}, createUnhandledErrorHandler = (message) => async (error) => {
   try {
-    const payload = {
+    let payload = {
       message,
       error: {
         message: error.message,
@@ -886,7 +631,7 @@ var createUnhandledErrorHandler = /* @__PURE__ */ __name((message) => async (err
   } finally {
     exit(1);
   }
-}, "createUnhandledErrorHandler");
+};
 process2.on(
   "uncaughtException",
   createUnhandledErrorHandler("Uncaught exception in the test runner process")