@storybook/addon-vitest 0.0.0-pr-32795-sha-81cf1f23 → 0.0.0-pr-32717-sha-f340a68b

package/dist/node/vitest.js

@@ -1,36 +1,37 @@
-import CJS_COMPAT_NODE_URL_75ibbepv58q from 'node:url';
-import CJS_COMPAT_NODE_PATH_75ibbepv58q from 'node:path';
-import CJS_COMPAT_NODE_MODULE_75ibbepv58q from "node:module";
+import CJS_COMPAT_NODE_URL_xvr6gehai1p from 'node:url';
+import CJS_COMPAT_NODE_PATH_xvr6gehai1p from 'node:path';
+import CJS_COMPAT_NODE_MODULE_xvr6gehai1p from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_75ibbepv58q.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_75ibbepv58q.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_75ibbepv58q.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_xvr6gehai1p.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_xvr6gehai1p.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_xvr6gehai1p.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
   log
-} from "../_node-chunks/chunk-PYDFQUST.js";
+} from "../_node-chunks/chunk-724JPUHM.js";
 import {
-  any,
-  errorToErrorLike
-} from "../_node-chunks/chunk-XTWQR354.js";
+  any
+} from "../_node-chunks/chunk-NGOGIT42.js";
 import {
   ADDON_ID,
   COVERAGE_DIRECTORY,
   STATUS_TYPE_ID_A11Y,
   STATUS_TYPE_ID_COMPONENT_TEST,
   storeOptions
-} from "../_node-chunks/chunk-ZI6UZG2P.js";
-import "../_node-chunks/chunk-KCHXXKAS.js";
+} from "../_node-chunks/chunk-KHNVQCL7.js";
+import "../_node-chunks/chunk-7ZCNTQXP.js";
 import {
   dirname,
   join,
   normalize,
   path
-} from "../_node-chunks/chunk-43MIUCD6.js";
-import "../_node-chunks/chunk-ML5LEYEM.js";
+} from "../_node-chunks/chunk-TXTKPPIA.js";
+import {
+  __name
+} from "../_node-chunks/chunk-K5BRNZW2.js";
 
 // src/node/vitest.ts
 import process2 from "node:process";
@@ -43,41 +44,85 @@ import {
 
 // ../../node_modules/es-toolkit/dist/function/debounce.mjs
 function debounce(func, debounceMs, { signal, edges } = {}) {
-  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();
+  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();
     }, debounceMs);
-  }, cancelTimer = () => {
-    timeoutId !== null && (clearTimeout(timeoutId), timeoutId = null);
-  }, cancel = () => {
-    cancelTimer(), pendingThis = void 0, pendingArgs = null;
-  }, flush = () => {
+  }, "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(() => {
     invoke();
-  }, debounced = function(...args) {
-    if (signal?.aborted)
+  }, "flush");
+  const debounced = /* @__PURE__ */ __name(function(...args) {
+    if (signal?.aborted) {
       return;
-    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;
+    }
+    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;
 }
+__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) {
-  let partialed = function(...providedArgs) {
-    let providedArgsIndex = 0, substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg), remainingArgs = providedArgs.slice(providedArgsIndex);
+  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);
     return func.apply(this, substitutedArgs.concat(remainingArgs));
-  };
-  return func.prototype && (partialed.prototype = Object.create(func.prototype)), partialed;
+  }, "partialed");
+  if (func.prototype) {
+    partialed.prototype = Object.create(func.prototype);
+  }
+  return partialed;
 }
+__name(partialImpl, "partialImpl");
 var placeholderSymbol = Symbol("partial.placeholder");
 partial.placeholder = placeholderSymbol;
 
@@ -85,13 +130,22 @@ partial.placeholder = placeholderSymbol;
 function partialRight(func, ...partialArgs) {
   return partialRightImpl(func, placeholderSymbol2, ...partialArgs);
 }
+__name(partialRight, "partialRight");
 function partialRightImpl(func, placeholder, ...partialArgs) {
-  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);
+  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);
     return func.apply(this, remainingArgs.concat(substitutedArgs));
-  };
-  return func.prototype && (partialedRight.prototype = Object.create(func.prototype)), partialedRight;
+  }, "partialedRight");
+  if (func.prototype) {
+    partialedRight.prototype = Object.create(func.prototype);
+  }
+  return partialedRight;
 }
+__name(partialRightImpl, "partialRightImpl");
 var placeholderSymbol2 = Symbol("partialRight.placeholder");
 partialRight.placeholder = placeholderSymbol2;
 
@@ -100,11 +154,36 @@ 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, 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);
+  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.apply(this, args);
+  }, "throttled");
+  throttled.cancel = debounced.cancel;
+  throttled.flush = debounced.flush;
+  return throttled;
+}
+__name(throttle, "throttle");
+
+// 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
   };
-  return throttled.cancel = debounced.cancel, throttled.flush = debounced.flush, throttled;
 }
+__name(errorToErrorLike, "errorToErrorLike");
 
 // src/node/vitest-manager.ts
 import { existsSync } from "node:fs";
@@ -112,19 +191,28 @@ import { getProjectRoot, resolvePathInStorybookCache } from "storybook/internal/
 
 // ../../node_modules/slash/index.js
 function slash(path2) {
-  return path2.startsWith("\\\\?\\") ? path2 : path2.replace(/\\/g, "/");
+  const isExtendedLengthPath = path2.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path2;
+  }
+  return 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) {
-    let { storyId, reports } = testCase.meta(), testResult = testCase.result();
+    const { storyId, reports } = testCase.meta();
+    const testResult = testCase.result();
     this.testManager.onTestCaseResult({
       storyId,
       testResult,
@@ -132,30 +220,42 @@ var StorybookReporter = class {
     });
   }
   async onTestRunEnd(testModules, unhandledErrors) {
-    let totalTestCount = testModules.flatMap(
+    const totalTestCount = testModules.flatMap(
       (t) => Array.from(t.children.allTests("passed")).concat(Array.from(t.children.allTests("failed")))
-    ).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
-    }));
+    ).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
+      };
+    });
     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"], VITEST_WORKSPACE_FILE_EXTENSION = ["ts", "js", "json"];
+var VITEST_CONFIG_FILE_EXTENSIONS = ["mts", "mjs", "cts", "cjs", "ts", "tsx", "js", "jsx"];
+var VITEST_WORKSPACE_FILE_EXTENSION = ["ts", "js", "json"];
 process.env.VITEST_STORYBOOK = "true";
-var DOUBLE_SPACES = "  ", getTestName = (name) => `${name}${DOUBLE_SPACES}`, VitestManager = class {
+var DOUBLE_SPACES = "  ";
+var getTestName = /* @__PURE__ */ __name((name) => `${name}${DOUBLE_SPACES}`, "getTestName");
+var VitestManager = class {
   constructor(testManager) {
     this.testManager = testManager;
     this.vitest = null;
@@ -163,32 +263,39 @@ var DOUBLE_SPACES = "  ", getTestName = (name) => `${name}${DOUBLE_SPACES}`, Vit
     this.vitestRestartPromise = null;
     this.runningPromise = null;
   }
+  static {
+    __name(this, "VitestManager");
+  }
   async startVitest({ coverage }) {
-    let { createVitest } = await import("vitest/node"), storybookCoverageReporter = [
+    const { createVitest } = await import("vitest/node");
+    const storybookCoverageReporter = [
       "@storybook/addon-vitest/internal/coverage-reporter",
       {
         testManager: this.testManager,
         coverageOptions: this.vitest?.config?.coverage
       }
-    ], coverageOptions = coverage ? {
-      enabled: !0,
-      clean: !0,
-      cleanOnRerun: !0,
-      reportOnFailure: !0,
+    ];
+    const coverageOptions = coverage ? {
+      enabled: true,
+      clean: true,
+      cleanOnRerun: true,
+      reportOnFailure: true,
       reporter: [["html", {}], storybookCoverageReporter],
       reportsDirectory: resolvePathInStorybookCache(COVERAGE_DIRECTORY)
-    } : { enabled: !1 }, vitestWorkspaceConfig = any(
+    } : { enabled: false };
+    const vitestWorkspaceConfig = any(
       [
         ...VITEST_WORKSPACE_FILE_EXTENSION.map((ext) => `vitest.workspace.${ext}`),
         ...VITEST_CONFIG_FILE_EXTENSIONS.map((ext) => `vitest.config.${ext}`)
       ],
       { last: getProjectRoot() }
-    ), projectName = "storybook:" + process.env.STORYBOOK_CONFIG_DIR;
+    );
+    const projectName = "storybook:" + process.env.STORYBOOK_CONFIG_DIR;
     try {
       this.vitest = await createVitest("test", {
         root: vitestWorkspaceConfig ? dirname(vitestWorkspaceConfig) : process.cwd(),
-        watch: !0,
-        passWithNoTests: !1,
+        watch: true,
+        passWithNoTests: false,
         project: [projectName],
         // TODO:
         // Do we want to enable Vite's default reporter?
@@ -199,104 +306,176 @@ var DOUBLE_SPACES = "  ", getTestName = (name) => `${name}${DOUBLE_SPACES}`, Vit
         coverage: coverageOptions
       });
     } catch (err) {
-      let originalMessage = String(err.message);
+      const originalMessage = String(err.message);
       if (originalMessage.includes("Found multiple projects")) {
-        let custom = [
+        const 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(`
-`);
-        originalMessage.startsWith(custom) || (err.message = `${custom}${originalMessage}`);
+        ].join("\n");
+        if (!originalMessage.startsWith(custom)) {
+          err.message = `${custom}${originalMessage}`;
+        }
       }
       throw err;
     }
-    this.vitest && this.vitest.onCancel(() => {
-    });
+    if (this.vitest) {
+      this.vitest.onCancel(() => {
+      });
+    }
     try {
       await this.vitest.init();
     } catch (e) {
-      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 += `
+      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 += `
 
-Please install the @vitest/${isIstanbul ? "coverage-istanbul" : "coverage-v8"} package to collect coverage
-`), this.testManager.reportFatalError(message, e);
+Please install the @vitest/${coveragePackage} package to collect coverage
+`;
+      }
+      this.testManager.reportFatalError(message, e);
       return;
     }
     await this.setupWatchers();
   }
   async restartVitest({ coverage }) {
-    return await this.vitestRestartPromise, this.vitestRestartPromise = new Promise(async (resolve, reject) => {
+    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;
       }
-    }), this.vitestRestartPromise;
+    });
+    return this.vitestRestartPromise;
   }
   resetGlobalTestNamePattern() {
     this.vitest?.setGlobalTestNamePattern("");
   }
   updateLastChanged(filepath) {
     this.vitest.projects.forEach(({ browser, vite, server }) => {
-      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));
+      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));
+      }
     });
   }
   async fetchStories(requestStoryIds) {
-    let indexUrl = this.testManager.store.getState().indexUrl;
-    if (!indexUrl)
+    const 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 {
-      let index = await Promise.race([
+      const index = await Promise.race([
         fetch(indexUrl).then((res) => res.json()),
         new Promise((_, reject) => setTimeout(reject, 3e3, new Error("Request took too long")))
       ]);
-      return (requestStoryIds || Object.keys(index.entries)).map((id) => index.entries[id]).filter((story) => story.type === "story");
+      const storyIds = requestStoryIds || Object.keys(index.entries);
+      return storyIds.map((id) => index.entries[id]).filter((story) => story.type === "story");
     } catch (e) {
-      return log("Failed to fetch story index: " + e.message), [];
+      log("Failed to fetch story index: " + e.message);
+      return [];
     }
   }
   filterTestSpecifications(testSpecifications, stories) {
-    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);
+    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);
     }
-    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(
+    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(
         ...filteredStories.filter((story) => !skip.some((tag) => story.tags?.includes(tag))).map((story) => story.id)
-      ));
+      );
     }
     return { filteredTestSpecifications, filteredStoryIds };
   }
   async runTests(runPayload) {
-    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)
+    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) {
         throw new Error(`Story ${runPayload.storyIds?.[0]} not found`);
-      let storyName = selectedStory.name, regex, isParentStory = allStories.some((story) => selectedStory.id === story.parent), hasParentStory = allStories.some((story) => selectedStory.parent === story.id);
+      }
+      const storyName = selectedStory.name;
+      let regex;
+      const isParentStory = allStories.some((story) => selectedStory.id === story.parent);
+      const hasParentStory = allStories.some((story) => selectedStory.parent === story.id);
       if (isParentStory) {
-        let parentName = getTestName(selectedStory.name);
+        const parentName = getTestName(selectedStory.name);
         regex = new RegExp(`^${parentName}`);
       } else if (hasParentStory) {
-        let parentStory = allStories.find((story) => story.id === selectedStory.parent);
-        if (!parentStory)
+        const parentStory = allStories.find((story) => story.id === selectedStory.parent);
+        if (!parentStory) {
           throw new Error(`Parent story not found for story ${selectedStory.id}`);
-        let parentName = getTestName(parentStory.name);
+        }
+        const parentName = getTestName(parentStory.name);
         regex = new RegExp(`^${parentName} ${storyName}$`);
-      } else
+      } else {
         regex = new RegExp(`^${storyName}$`);
+      }
       this.vitest.setGlobalTestNamePattern(regex);
     }
-    let { filteredTestSpecifications, filteredStoryIds } = this.filterTestSpecifications(
+    const { filteredTestSpecifications, filteredStoryIds } = this.filterTestSpecifications(
       testSpecifications,
       filteredStories
     );
@@ -306,92 +485,138 @@ Please install the @vitest/${isIstanbul ? "coverage-istanbul" : "coverage-v8"} p
         ...s.currentRun,
         totalTestCount: filteredStoryIds.length
       }
-    })), await this.vitest.runTestSpecifications(filteredTestSpecifications, !0), this.resetGlobalTestNamePattern();
+    }));
+    await this.vitest.runTestSpecifications(filteredTestSpecifications, true);
+    this.resetGlobalTestNamePattern();
   }
   async cancelCurrentRun() {
-    await this.vitest?.cancelCurrentRun("keyboard-input"), await this.runningPromise;
+    await this.vitest?.cancelCurrentRun("keyboard-input");
+    await this.runningPromise;
   }
   async getStorybookTestSpecifications() {
-    return (await this.vitest?.globTestSpecifications() ?? []).filter(
+    const globTestSpecifications = await this.vitest?.globTestSpecifications() ?? [];
+    return globTestSpecifications.filter(
       (workspaceSpec) => this.isStorybookProject(workspaceSpec.project)
     ) ?? [];
   }
   async runAffectedTestsAfterChange(changedFilePath, event) {
-    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)
+    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) {
       return;
+    }
     this.resetGlobalTestNamePattern();
-    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(
+    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(
       (project) => project.config.setupFiles.map((setupFile) => ({
         project,
         moduleId: setupFile
       }))
-    ), syntheticGlobalTestSpecifications = previewAnnotationSpecifications.concat(setupFilesSpecifications), testSpecifications = await this.getStorybookTestSpecifications(), allStories = await this.fetchStories(), affectsGlobalFiles = !1, affectedTestSpecifications = (await Promise.all(
+    );
+    const syntheticGlobalTestSpecifications = previewAnnotationSpecifications.concat(setupFilesSpecifications);
+    const testSpecifications = await this.getStorybookTestSpecifications();
+    const allStories = await this.fetchStories();
+    let affectsGlobalFiles = false;
+    const affectedTestSpecifications = (await Promise.all(
       syntheticGlobalTestSpecifications.concat(testSpecifications).map(async (testSpecification) => {
-        let dependencies = await this.getTestDependencies(testSpecification);
-        if (changedFilePath === testSpecification.moduleId || dependencies.has(changedFilePath))
-          return syntheticGlobalTestSpecifications.includes(testSpecification) && (affectsGlobalFiles = !0), testSpecification;
+        const dependencies = await this.getTestDependencies(testSpecification);
+        if (changedFilePath === testSpecification.moduleId || dependencies.has(changedFilePath)) {
+          if (syntheticGlobalTestSpecifications.includes(testSpecification)) {
+            affectsGlobalFiles = true;
+          }
+          return testSpecification;
+        }
       })
-    )).filter(Boolean), testSpecificationsToRun = affectsGlobalFiles ? testSpecifications : affectedTestSpecifications;
-    if (!testSpecificationsToRun.length)
+    )).filter(Boolean);
+    const testSpecificationsToRun = affectsGlobalFiles ? testSpecifications : affectedTestSpecifications;
+    if (!testSpecificationsToRun.length) {
       return;
-    let { filteredTestSpecifications, filteredStoryIds } = this.filterTestSpecifications(
+    }
+    const { filteredTestSpecifications, filteredStoryIds } = this.filterTestSpecifications(
       testSpecificationsToRun,
       allStories
     );
     await this.testManager.runTestsWithState({
       storyIds: filteredStoryIds,
       triggeredBy: "watch",
-      callback: async () => {
+      callback: /* @__PURE__ */ __name(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, !1);
-      }
+        }));
+        await this.vitest.cancelCurrentRun("keyboard-input");
+        await this.runningPromise;
+        await this.vitest.runTestSpecifications(filteredTestSpecifications, false);
+      }, "callback")
     });
   }
   // 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) {
-    let deps = /* @__PURE__ */ new Set(), addImports = async (project, filepath) => {
-      if (deps.has(filepath))
+    const deps = /* @__PURE__ */ new Set();
+    const addImports = /* @__PURE__ */ __name(async (project, filepath) => {
+      if (deps.has(filepath)) {
         return;
+      }
       deps.add(filepath);
-      let transformed = project.vite.moduleGraph.getModuleById(filepath)?.ssrTransformResult || await project.vite.transformRequest(filepath, { ssr: !0 });
-      if (!transformed)
+      const mod = project.vite.moduleGraph.getModuleById(filepath);
+      const transformed = mod?.ssrTransformResult || await project.vite.transformRequest(filepath, { ssr: true });
+      if (!transformed) {
         return;
-      let dependencies = [...transformed.deps ?? [], ...transformed.dynamicDeps ?? []];
+      }
+      const dependencies = [...transformed.deps ?? [], ...transformed.dynamicDeps ?? []];
       await Promise.all(
         dependencies.map(async (dep) => {
-          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);
+          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);
+          }
         })
       );
-    };
-    return await addImports(spec.project, spec.moduleId), deps.delete(spec.moduleId), deps;
+    }, "addImports");
+    await addImports(spec.project, spec.moduleId);
+    deps.delete(spec.moduleId);
+    return deps;
   }
   async registerVitestConfigListener() {
     this.vitest.vite.watcher.on("change", async (file) => {
-      if (normalize(file) === this.vitest?.vite?.config.configFile) {
+      const isConfig = normalize(file) === this.vitest?.vite?.config.configFile;
+      if (isConfig) {
         log("Restarting Vitest due to config change");
-        let { watching, config } = this.testManager.store.getState();
+        const { 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__;
@@ -405,7 +630,8 @@ var testStateToStatusValueMap = {
   warning: "status-value:warning",
   failed: "status-value:error",
   skipped: "status-value:unknown"
-}, TestManager = class _TestManager {
+};
+var TestManager = class _TestManager {
   constructor(options) {
     this.batchedTestCaseResults = [];
     /**
@@ -423,15 +649,28 @@ var testStateToStatusValueMap = {
      * eventually causing the manager and dev server to lose connection.
      */
     this.throttledFlushTestCaseResults = throttle(() => {
-      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;
+      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;
         testCaseResultsToFlush.forEach(({ testResult, reports }) => {
-          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++;
+          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++;
+            }
           });
         });
-        let finishedTestCount = ctSuccess + ctError;
+        const finishedTestCount = ctSuccess + ctError;
         return {
           ...s,
           currentRun: {
@@ -445,57 +684,75 @@ var testStateToStatusValueMap = {
           }
         };
       });
-      let componentTestStatuses = testCaseResultsToFlush.map(({ storyId, testResult }) => ({
+      const 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(`
-`) ?? "",
-        sidebarContextMenu: !1
+        description: testResult.errors?.map((error) => error.stack || error.message).join("\n") ?? "",
+        sidebarContextMenu: false
       }));
       this.componentTestStatusStore.set(componentTestStatuses);
-      let a11yStatuses = testCaseResultsToFlush.flatMap(
+      const 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: !1
+          sidebarContextMenu: false
         }))
       ).filter((a11yStatus) => a11yStatus !== void 0);
-      a11yStatuses.length > 0 && this.a11yStatusStore.set(a11yStatuses);
+      if (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(() => 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(() => {
+      return 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: async () => {
+      callback: /* @__PURE__ */ __name(async () => {
         try {
-          await this.vitestManager.vitestRestartPromise, await this.vitestManager.runTests(event.payload);
+          await this.vitestManager.vitestRestartPromise;
+          await this.vitestManager.runTests(event.payload);
         } catch (err) {
-          throw this.reportFatalError("Failed to run tests", err), err;
+          this.reportFatalError("Failed to run tests", err);
+          throw err;
         }
-      }
+      }, "callback")
     });
   }
   async handleCancelEvent() {
     try {
       this.store.setState((s) => ({
         ...s,
-        cancelling: !0
-      })), await this.vitestManager.cancelCurrentRun();
+        cancelling: true
+      }));
+      await this.vitestManager.cancelCurrentRun();
     } catch (err) {
       this.reportFatalError("Failed to cancel tests", err);
     } finally {
       this.store.setState((s) => ({
         ...s,
-        cancelling: !1
+        cancelling: false
       }));
     }
   }
@@ -504,7 +761,9 @@ var testStateToStatusValueMap = {
     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,
@@ -513,12 +772,17 @@ var testStateToStatusValueMap = {
         storyIds,
         config: s.config
       }
-    })), process.env.VITEST_STORYBOOK_CONFIG = JSON.stringify(this.store.getState().config), await this.testProviderStore.runWithState(async () => {
-      if (await callback(), this.store.send({
+    }));
+    process.env.VITEST_STORYBOOK_CONFIG = JSON.stringify(this.store.getState().config);
+    await this.testProviderStore.runWithState(async () => {
+      await callback();
+      this.store.send({
         type: "TEST_RUN_COMPLETED",
         payload: this.store.getState().currentRun
-      }), this.store.getState().currentRun.unhandledErrors.length > 0)
+      });
+      if (this.store.getState().currentRun.unhandledErrors.length > 0) {
         throw new Error("Tests completed but there are unhandled errors");
+      }
     });
   }
   onTestModuleCollected(collectedTestCount) {
@@ -531,11 +795,16 @@ var testStateToStatusValueMap = {
     }));
   }
   onTestCaseResult(result) {
-    let { storyId, testResult, reports } = result;
-    storyId && (this.batchedTestCaseResults.push({ storyId, testResult, reports }), this.throttledFlushTestCaseResults());
+    const { storyId, testResult, reports } = result;
+    if (!storyId) {
+      return;
+    }
+    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,
@@ -555,7 +824,8 @@ var testStateToStatusValueMap = {
     }));
   }
   async reportFatalError(message, error) {
-    await this.store.untilReady(), this.store.send({
+    await this.store.untilReady();
+    this.store.send({
       type: "FATAL_ERROR",
       payload: {
         message,
@@ -565,26 +835,30 @@ var testStateToStatusValueMap = {
   }
   static async start(options) {
     return new Promise((resolve) => {
-      let testManager = new _TestManager({
+      const testManager = new _TestManager({
         ...options,
-        onReady: () => {
-          resolve(testManager), options.onReady?.();
-        }
+        onReady: /* @__PURE__ */ __name(() => {
+          resolve(testManager);
+          options.onReady?.();
+        }, "onReady")
       });
     });
   }
 };
 
 // src/node/vitest.ts
-var UniversalStore = experimental_UniversalStore, getStatusStore = experimental_getStatusStore, getTestProviderStore = experimental_getTestProviderStore, channel = new Channel({
-  async: !0,
+var UniversalStore = experimental_UniversalStore;
+var getStatusStore = experimental_getStatusStore;
+var getTestProviderStore = experimental_getTestProviderStore;
+var channel = new Channel({
+  async: true,
   transport: {
-    send: (event) => {
+    send: /* @__PURE__ */ __name((event) => {
       process2.send?.(event);
-    },
-    setHandler: (handler) => {
+    }, "send"),
+    setHandler: /* @__PURE__ */ __name((handler) => {
       process2.on("message", handler);
-    }
+    }, "setHandler")
   }
 });
 UniversalStore.__prepare(channel, UniversalStore.Environment.SERVER);
@@ -594,18 +868,20 @@ new TestManager({
   componentTestStatusStore: getStatusStore(STATUS_TYPE_ID_COMPONENT_TEST),
   a11yStatusStore: getStatusStore(STATUS_TYPE_ID_A11Y),
   testProviderStore: getTestProviderStore(ADDON_ID),
-  onReady: () => {
+  onReady: /* @__PURE__ */ __name(() => {
     process2.send?.({ type: "ready" });
-  },
+  }, "onReady"),
   storybookOptions: {
     configDir: process2.env.STORYBOOK_CONFIG_DIR || ""
   }
 });
-var exit = (code = 0) => {
-  channel?.removeAllListeners(), process2.exit(code);
-}, createUnhandledErrorHandler = (message) => async (error) => {
+var exit = /* @__PURE__ */ __name((code = 0) => {
+  channel?.removeAllListeners();
+  process2.exit(code);
+}, "exit");
+var createUnhandledErrorHandler = /* @__PURE__ */ __name((message) => async (error) => {
   try {
-    let payload = {
+    const payload = {
       message,
       error: {
         message: error.message,
@@ -621,7 +897,7 @@ var exit = (code = 0) => {
   } finally {
     exit(1);
   }
-};
+}, "createUnhandledErrorHandler");
 process2.on(
   "uncaughtException",
   createUnhandledErrorHandler("Uncaught exception in the test runner process")