storybook 10.0.0-beta.1 → 10.0.0-beta.11

package/dist/_node-chunks/{chunk-GVCXNIAA.js → chunk-UC6O5PNX.js}

@@ -1,21 +1,21 @@
-import CJS_COMPAT_NODE_URL_nodb7gfupnb from 'node:url';
-import CJS_COMPAT_NODE_PATH_nodb7gfupnb from 'node:path';
-import CJS_COMPAT_NODE_MODULE_nodb7gfupnb from "node:module";
+import CJS_COMPAT_NODE_URL_91hxho9jtpf from 'node:url';
+import CJS_COMPAT_NODE_PATH_91hxho9jtpf from 'node:path';
+import CJS_COMPAT_NODE_MODULE_91hxho9jtpf from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_nodb7gfupnb.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_nodb7gfupnb.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_nodb7gfupnb.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_91hxho9jtpf.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_91hxho9jtpf.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_91hxho9jtpf.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
   require_dist
-} from "./chunk-WDKWVNL2.js";
+} from "./chunk-EBLOP2C5.js";
 import {
   __name,
   __toESM
-} from "./chunk-SUMFFLGF.js";
+} from "./chunk-Q5IJJX3T.js";
 
 // src/csf-tools/CsfFile.ts
 var import_ts_dedent = __toESM(require_dist(), 1);
@@ -28,7 +28,7 @@ import {
   types as t2,
   traverse
 } from "storybook/internal/babel";
-import { isExportStory, storyNameFromExport, toId } from "storybook/internal/csf";
+import { isExportStory, storyNameFromExport, toId, toTestId } from "storybook/internal/csf";
 import { logger } from "storybook/internal/node-logger";
 
 // src/csf-tools/findVarInitialization.ts
@@ -86,6 +86,29 @@ function parseTags(prop) {
   });
 }
 __name(parseTags, "parseTags");
+function parseTestTags(optionsNode, program) {
+  if (!optionsNode) {
+    return [];
+  }
+  let node = optionsNode;
+  if (t2.isIdentifier(node)) {
+    node = findVarInitialization(node.name, program);
+  }
+  if (t2.isObjectExpression(node)) {
+    const tagsProp = node.properties.find(
+      (property) => t2.isObjectProperty(property) && t2.isIdentifier(property.key) && property.key.name === "tags"
+    );
+    if (tagsProp) {
+      let tagsNode = tagsProp.value;
+      if (t2.isIdentifier(tagsNode)) {
+        tagsNode = findVarInitialization(tagsNode.name, program);
+      }
+      return parseTags(tagsNode);
+    }
+  }
+  return [];
+}
+__name(parseTestTags, "parseTestTags");
 var formatLocation = /* @__PURE__ */ __name((node, fileName) => {
   let loc = "";
   if (node.loc) {
@@ -165,7 +188,7 @@ var NoMetaError = class extends Error {
     super(import_ts_dedent.dedent`
       CSF: ${msg} ${formatLocation(ast, fileName)}
       
-      More info: https://storybook.js.org/docs/writing-stories#default-export?ref=error
+      More info: https://storybook.js.org/docs/writing-stories?ref=error#default-export
     `);
     this.name = this.constructor.name;
   }
@@ -179,7 +202,7 @@ var MultipleMetaError = class extends Error {
     super(import_ts_dedent.dedent`
       CSF: ${message} ${formatLocation(ast, fileName)}
       
-      More info: https://storybook.js.org/docs/writing-stories#default-export?ref=error
+      More info: https://storybook.js.org/docs/writing-stories?ref=error#default-export
     `);
     this.name = this.constructor.name;
   }
@@ -193,7 +216,7 @@ var MixedFactoryError = class extends Error {
     super(import_ts_dedent.dedent`
       CSF: ${message} ${formatLocation(ast, fileName)}
       
-      More info: https://storybook.js.org/docs/writing-stories#default-export?ref=error
+      More info: https://storybook.js.org/docs/writing-stories?ref=error#default-export
     `);
     this.name = this.constructor.name;
   }
@@ -207,7 +230,7 @@ var BadMetaError = class extends Error {
     super(import_ts_dedent.dedent`
       CSF: ${message} ${formatLocation(ast, fileName)}
       
-      More info: https://storybook.js.org/docs/writing-stories#default-export?ref=error
+      More info: https://storybook.js.org/docs/writing-stories?ref=error#default-export
     `);
     this.name = this.constructor.name;
   }
@@ -221,6 +244,7 @@ var CsfFile = class {
     this._storyStatements = {};
     this._storyAnnotations = {};
     this._templates = {};
+    this._tests = [];
     this._ast = ast;
     this._file = file;
     this._options = options;
@@ -339,9 +363,15 @@ var CsfFile = class {
             metaNode = decl;
           } else if (
             // export default { ... } as Meta<...>
+            // export default { ... } satisfies Meta<...>
             (t2.isTSAsExpression(decl) || t2.isTSSatisfiesExpression(decl)) && t2.isObjectExpression(decl.expression)
           ) {
             metaNode = decl.expression;
+          } else if (
+            // export default { ... } satisfies Meta as Meta<...>
+            t2.isTSAsExpression(decl) && t2.isTSSatisfiesExpression(decl.expression) && t2.isObjectExpression(decl.expression.expression)
+          ) {
+            metaNode = decl.expression.expression;
           }
           if (metaNode && t2.isProgram(parent)) {
             self._parseMeta(metaNode, parent);
@@ -387,7 +417,13 @@ var CsfFile = class {
                 }
                 let storyNode;
                 if (t2.isVariableDeclarator(decl)) {
-                  storyNode = t2.isTSAsExpression(decl.init) || t2.isTSSatisfiesExpression(decl.init) ? decl.init.expression : decl.init;
+                  if (t2.isTSAsExpression(decl.init) && t2.isTSSatisfiesExpression(decl.init.expression)) {
+                    storyNode = decl.init.expression.expression;
+                  } else if (t2.isTSAsExpression(decl.init) || t2.isTSSatisfiesExpression(decl.init)) {
+                    storyNode = decl.init.expression;
+                  } else {
+                    storyNode = decl.init;
+                  }
                 } else {
                   storyNode = decl;
                 }
@@ -469,9 +505,15 @@ var CsfFile = class {
                     metaNode = decl;
                   } else if (
                     // export default { ... } as Meta<...>
-                    t2.isTSAsExpression(decl) && t2.isObjectExpression(decl.expression)
+                    // export default { ... } satisfies Meta<...>
+                    (t2.isTSAsExpression(decl) || t2.isTSSatisfiesExpression(decl)) && t2.isObjectExpression(decl.expression)
                   ) {
                     metaNode = decl.expression;
+                  } else if (
+                    // export default { ... } satisfies Meta as Meta<...>
+                    t2.isTSAsExpression(decl) && t2.isTSSatisfiesExpression(decl.expression) && t2.isObjectExpression(decl.expression.expression)
+                  ) {
+                    metaNode = decl.expression.expression;
                   }
                   if (metaNode && t2.isProgram(parent)) {
                     self._parseMeta(metaNode, parent);
@@ -529,6 +571,24 @@ var CsfFile = class {
               story.name = storyName;
             }
           }
+          if (t2.isCallExpression(expression) && t2.isMemberExpression(expression.callee) && t2.isIdentifier(expression.callee.object) && t2.isIdentifier(expression.callee.property) && expression.callee.property.name === "test" && expression.arguments.length >= 2 && t2.isStringLiteral(expression.arguments[0])) {
+            const exportName = expression.callee.object.name;
+            const testName = expression.arguments[0].value;
+            const testFunction = expression.arguments.length === 2 ? expression.arguments[1] : expression.arguments[2];
+            const testArguments = expression.arguments.length === 2 ? null : expression.arguments[1];
+            const tags = parseTestTags(testArguments, self._ast.program);
+            self._tests.push({
+              function: testFunction,
+              name: testName,
+              node: expression,
+              // can't set id because meta title isn't available yet
+              // so it's set later on
+              id: "FIXME",
+              tags,
+              parent: { node: self._storyStatements[exportName] }
+            });
+            self._stories[exportName].__stats.tests = true;
+          }
         }
       },
       CallExpression: {
@@ -539,7 +599,7 @@ var CsfFile = class {
             throw new Error(import_ts_dedent.dedent`
               Unexpected \`storiesOf\` usage: ${formatLocation(node, self._options.fileName)}.
 
-              SB8 does not support \`storiesOf\`. 
+              SB8 does not support \`storiesOf\`.
             `);
           }
           if (t2.isMemberExpression(callee) && t2.isIdentifier(callee.property) && callee.property.name === "meta" && t2.isIdentifier(callee.object) && node.arguments.length > 0) {
@@ -547,9 +607,12 @@ var CsfFile = class {
             const configParent = configCandidate?.path?.parentPath?.node;
             if (t2.isImportDeclaration(configParent)) {
               if (isValidPreviewPath(configParent.source.value)) {
-                const metaNode = node.arguments[0];
-                self._metaVariableName = callee.property.name;
                 self._metaIsFactory = true;
+                const metaDeclarator = path.findParent(
+                  (p) => p.isVariableDeclarator()
+                );
+                self._metaVariableName = t2.isIdentifier(metaDeclarator.node.id) ? metaDeclarator.node.id.name : callee.property.name;
+                const metaNode = node.arguments[0];
                 self._parseMeta(metaNode, self._ast.program);
               } else {
                 throw new BadMetaError(
@@ -610,6 +673,14 @@ var CsfFile = class {
         stats.storyFn = !!(t2.isArrowFunctionExpression(storyExport) || t2.isFunctionDeclaration(storyExport));
         stats.mount = hasMount(storyAnnotations.play ?? self._metaAnnotations.play);
         stats.moduleMock = !!self.imports.find((fname) => isModuleMock(fname));
+        const storyNode = self._storyStatements[key];
+        const storyTests = self._tests.filter((t7) => t7.parent.node === storyNode);
+        if (storyTests.length > 0) {
+          stats.tests = true;
+          storyTests.forEach((test) => {
+            test.id = toTestId(id, test.name);
+          });
+        }
         return acc;
       },
       {}
@@ -642,6 +713,13 @@ var CsfFile = class {
   get stories() {
     return Object.values(this._stories);
   }
+  getStoryTests(story) {
+    const storyNode = typeof story === "string" ? this._storyStatements[story] : story;
+    if (!storyNode) {
+      return [];
+    }
+    return this._tests.filter((t7) => t7.parent.node === storyNode);
+  }
   get indexInputs() {
     const { fileName } = this._options;
     if (!fileName) {
@@ -650,21 +728,52 @@ var CsfFile = class {
         Either add the fileName option when creating the CsfFile instance, or create the index inputs manually.`
       );
     }
-    return Object.entries(this._stories).map(([exportName, story]) => {
+    const index = [];
+    Object.entries(this._stories).map(([exportName, story]) => {
       const tags = [...this._meta?.tags ?? [], ...story.tags ?? []];
-      return {
-        type: "story",
+      const storyInput = {
         importPath: fileName,
         rawComponentPath: this._rawComponentPath,
         exportName,
-        name: story.name,
         title: this.meta?.title,
         metaId: this.meta?.id,
         tags,
         __id: story.id,
         __stats: story.__stats
       };
+      const tests = this.getStoryTests(exportName);
+      const hasTests = tests.length > 0;
+      index.push({
+        ...storyInput,
+        type: "story",
+        subtype: "story",
+        name: story.name
+      });
+      if (hasTests) {
+        tests.forEach((test) => {
+          index.push({
+            ...storyInput,
+            // TODO implementent proper title => path behavior in `transformStoryIndexToStoriesHash`
+            // title: `${storyInput.title}/${story.name}`,
+            type: "story",
+            subtype: "test",
+            name: test.name,
+            parent: story.id,
+            parentName: story.name,
+            tags: [
+              ...storyInput.tags,
+              // this tag comes before test tags so users can invert if they like
+              "!autodocs",
+              ...test.tags,
+              // this tag comes after test tags so users can't change it
+              "test-fn"
+            ],
+            __id: test.id
+          });
+        });
+      }
     });
+    return index;
   }
 };
 var babelParseFile = /* @__PURE__ */ __name(({
@@ -1425,6 +1534,116 @@ var ConfigFile = class {
       }
     }
   }
+  _removeRequireImport(importSpecifier, fromImport) {
+    const requireDeclarationIndex = this._ast.program.body.findIndex((node) => {
+      const hasDeclaration = t3.isVariableDeclaration(node) && node.declarations.length === 1 && t3.isVariableDeclarator(node.declarations[0]) && t3.isCallExpression(node.declarations[0].init) && t3.isIdentifier(node.declarations[0].init.callee) && node.declarations[0].init.callee.name === "require" && t3.isStringLiteral(node.declarations[0].init.arguments[0]) && (node.declarations[0].init.arguments[0].value === fromImport || node.declarations[0].init.arguments[0].value === fromImport.split("node:")[1]);
+      return hasDeclaration;
+    });
+    if (requireDeclarationIndex === -1) {
+      return;
+    }
+    const requireDeclaration = this._ast.program.body[requireDeclarationIndex];
+    const declarator = requireDeclaration.declarations[0];
+    if (importSpecifier === null) {
+      return;
+    }
+    if (typeof importSpecifier === "string") {
+      if (t3.isIdentifier(declarator.id) && declarator.id.name === importSpecifier) {
+        this._ast.program.body.splice(requireDeclarationIndex, 1);
+      }
+      return;
+    }
+    if (typeof importSpecifier === "object" && "namespace" in importSpecifier) {
+      return;
+    }
+    if (Array.isArray(importSpecifier) && t3.isObjectPattern(declarator.id)) {
+      const objectPattern = declarator.id;
+      importSpecifier.forEach((specifier) => {
+        const index = objectPattern.properties.findIndex(
+          (prop) => t3.isObjectProperty(prop) && t3.isIdentifier(prop.key) && prop.key.name === specifier
+        );
+        if (index !== -1) {
+          objectPattern.properties.splice(index, 1);
+        }
+      });
+      if (objectPattern.properties.length === 0) {
+        this._ast.program.body.splice(requireDeclarationIndex, 1);
+      }
+    }
+  }
+  _removeImport(importSpecifier, fromImport) {
+    const importDeclarationIndex = this._ast.program.body.findIndex(
+      (node) => t3.isImportDeclaration(node) && (node.source.value === fromImport || node.source.value === fromImport.split("node:")[1])
+    );
+    if (importDeclarationIndex === -1) {
+      return;
+    }
+    const importDeclaration = this._ast.program.body[importDeclarationIndex];
+    if (importSpecifier === null) {
+      if (importDeclaration.specifiers.length === 0) {
+        this._ast.program.body.splice(importDeclarationIndex, 1);
+      }
+      return;
+    }
+    if (typeof importSpecifier === "object" && "namespace" in importSpecifier) {
+      const index = importDeclaration.specifiers.findIndex(
+        (specifier) => t3.isImportNamespaceSpecifier(specifier) && t3.isIdentifier(specifier.local) && specifier.local.name === importSpecifier.namespace
+      );
+      if (index !== -1) {
+        importDeclaration.specifiers.splice(index, 1);
+      }
+    }
+    if (typeof importSpecifier === "string") {
+      const index = importDeclaration.specifiers.findIndex(
+        (specifier) => t3.isImportDefaultSpecifier(specifier) && t3.isIdentifier(specifier.local) && specifier.local.name === importSpecifier
+      );
+      if (index !== -1) {
+        importDeclaration.specifiers.splice(index, 1);
+      }
+    }
+    if (Array.isArray(importSpecifier)) {
+      importSpecifier.forEach((specifier) => {
+        const index = importDeclaration.specifiers.findIndex(
+          (current) => t3.isImportSpecifier(current) && t3.isIdentifier(current.imported) && current.imported.name === specifier
+        );
+        if (index !== -1) {
+          importDeclaration.specifiers.splice(index, 1);
+        }
+      });
+    }
+    if (importDeclaration.specifiers.length === 0) {
+      this._ast.program.body.splice(importDeclarationIndex, 1);
+    }
+  }
+  /**
+   * Remove import specifiers for a given import statement.
+   *
+   * Does not support removing type imports (yet)
+   *
+   * @example
+   *
+   * ```ts
+   * // import { foo } from 'bar';
+   * setImport(['foo'], 'bar');
+   *
+   * // import foo from 'bar';
+   * setImport('foo', 'bar');
+   *
+   * // import * as foo from 'bar';
+   * setImport({ namespace: 'foo' }, 'bar');
+   *
+   * // import 'bar';
+   * setImport(null, 'bar');
+   * ```
+   *
+   * @param importSpecifiers - The import specifiers to remove. If a string is passed in, will only
+   *   remove the default import. Otherwise, named imports matching the array will be removed.
+   * @param fromImport - The module to import from
+   */
+  removeImport(importSpecifier, fromImport) {
+    this._removeRequireImport(importSpecifier, fromImport);
+    this._removeImport(importSpecifier, fromImport);
+  }
 };
 var loadConfig = /* @__PURE__ */ __name((code, fileName) => {
   const ast = babelParse2(code);
@@ -1749,6 +1968,8 @@ var isValidTest = /* @__PURE__ */ __name((storyTags, tagsFilter) => {
   }
   return true;
 }, "isValidTest");
+var DOUBLE_SPACES = "  ";
+var getLiteralWithZeroWidthSpace = /* @__PURE__ */ __name((testTitle) => t6.stringLiteral(`${testTitle}${DOUBLE_SPACES}`), "getLiteralWithZeroWidthSpace");
 async function vitestTransform({
   code,
   fileName,
@@ -1796,7 +2017,7 @@ async function vitestTransform({
     );
   }
   const validStories = {};
-  Object.keys(parsed._stories).map((key) => {
+  Object.keys(parsed._stories).forEach((key) => {
     const finalTags = combineTags(
       "test",
       "dev",
@@ -1817,7 +2038,7 @@ async function vitestTransform({
       ])
     );
     ast.program.body.push(describeSkipBlock);
-    const imports = [
+    const imports2 = [
       t6.importDeclaration(
         [
           t6.importSpecifier(vitestTestId, t6.identifier("test")),
@@ -1826,103 +2047,165 @@ async function vitestTransform({
         t6.stringLiteral("vitest")
       )
     ];
-    ast.program.body.unshift(...imports);
-  } else {
-    let getTestGuardDeclaration2 = function() {
-      const isRunningFromThisFileId2 = parsed._file.path.scope.generateUidIdentifier("isRunningFromThisFile");
-      const testPathProperty = t6.memberExpression(
-        t6.callExpression(t6.memberExpression(vitestExpectId, t6.identifier("getState")), []),
-        t6.identifier("testPath")
-      );
-      const filePathProperty = t6.memberExpression(
-        t6.memberExpression(t6.identifier("globalThis"), t6.identifier("__vitest_worker__")),
-        t6.identifier("filepath")
-      );
-      const nullishCoalescingExpression = t6.logicalExpression(
-        "??",
-        // TODO: switch order of testPathProperty and filePathProperty when the bug is fixed
-        // https://github.com/vitest-dev/vitest/issues/6367 (or probably just use testPathProperty)
-        filePathProperty,
-        testPathProperty
-      );
-      const includesCall = t6.callExpression(
-        t6.memberExpression(
-          t6.callExpression(t6.identifier("convertToFilePath"), [
-            t6.memberExpression(
-              t6.memberExpression(t6.identifier("import"), t6.identifier("meta")),
-              t6.identifier("url")
-            )
-          ]),
-          t6.identifier("includes")
-        ),
-        [nullishCoalescingExpression]
-      );
-      const isRunningFromThisFileDeclaration2 = t6.variableDeclaration("const", [
-        t6.variableDeclarator(isRunningFromThisFileId2, includesCall)
-      ]);
-      return { isRunningFromThisFileDeclaration: isRunningFromThisFileDeclaration2, isRunningFromThisFileId: isRunningFromThisFileId2 };
-    };
-    var getTestGuardDeclaration = getTestGuardDeclaration2;
-    __name(getTestGuardDeclaration2, "getTestGuardDeclaration");
-    const vitestExpectId = parsed._file.path.scope.generateUidIdentifier("expect");
-    const testStoryId = parsed._file.path.scope.generateUidIdentifier("testStory");
-    const skipTagsId = t6.identifier(JSON.stringify(tagsFilter.skip));
-    const { isRunningFromThisFileDeclaration, isRunningFromThisFileId } = getTestGuardDeclaration2();
-    ast.program.body.push(isRunningFromThisFileDeclaration);
-    const getTestStatementForStory = /* @__PURE__ */ __name(({
-      localName,
-      exportName,
-      testTitle,
-      node
-    }) => {
-      const testStoryCall = t6.expressionStatement(
-        t6.callExpression(vitestTestId, [
-          t6.stringLiteral(testTitle),
-          t6.callExpression(testStoryId, [
-            t6.stringLiteral(exportName),
-            t6.identifier(localName),
-            t6.identifier(metaExportName),
-            skipTagsId
-          ])
+    ast.program.body.unshift(...imports2);
+    return formatCsf(parsed, { sourceMaps: true, sourceFileName: fileName }, code);
+  }
+  const vitestExpectId = parsed._file.path.scope.generateUidIdentifier("expect");
+  const testStoryId = parsed._file.path.scope.generateUidIdentifier("testStory");
+  const skipTagsId = t6.identifier(JSON.stringify(tagsFilter.skip));
+  function getTestGuardDeclaration() {
+    const isRunningFromThisFileId2 = parsed._file.path.scope.generateUidIdentifier("isRunningFromThisFile");
+    const testPathProperty = t6.memberExpression(
+      t6.callExpression(t6.memberExpression(vitestExpectId, t6.identifier("getState")), []),
+      t6.identifier("testPath")
+    );
+    const filePathProperty = t6.memberExpression(
+      t6.memberExpression(t6.identifier("globalThis"), t6.identifier("__vitest_worker__")),
+      t6.identifier("filepath")
+    );
+    const nullishCoalescingExpression = t6.logicalExpression(
+      "??",
+      // TODO: switch order of testPathProperty and filePathProperty when the bug is fixed
+      // https://github.com/vitest-dev/vitest/issues/6367 (or probably just use testPathProperty)
+      filePathProperty,
+      testPathProperty
+    );
+    const includesCall = t6.callExpression(
+      t6.memberExpression(
+        t6.callExpression(t6.identifier("convertToFilePath"), [
+          t6.memberExpression(
+            t6.memberExpression(t6.identifier("import"), t6.identifier("meta")),
+            t6.identifier("url")
+          )
+        ]),
+        t6.identifier("includes")
+      ),
+      [nullishCoalescingExpression]
+    );
+    const isRunningFromThisFileDeclaration2 = t6.variableDeclaration("const", [
+      t6.variableDeclarator(isRunningFromThisFileId2, includesCall)
+    ]);
+    return { isRunningFromThisFileDeclaration: isRunningFromThisFileDeclaration2, isRunningFromThisFileId: isRunningFromThisFileId2 };
+  }
+  __name(getTestGuardDeclaration, "getTestGuardDeclaration");
+  const { isRunningFromThisFileDeclaration, isRunningFromThisFileId } = getTestGuardDeclaration();
+  ast.program.body.push(isRunningFromThisFileDeclaration);
+  const getTestStatementForStory = /* @__PURE__ */ __name(({
+    localName,
+    exportName,
+    testTitle,
+    node,
+    overrideSourcemap = true,
+    storyId
+  }) => {
+    const testStoryCall = t6.expressionStatement(
+      t6.callExpression(vitestTestId, [
+        t6.stringLiteral(testTitle),
+        t6.callExpression(testStoryId, [
+          t6.stringLiteral(exportName),
+          t6.identifier(localName),
+          t6.identifier(metaExportName),
+          skipTagsId,
+          t6.stringLiteral(storyId)
         ])
-      );
+      ])
+    );
+    if (overrideSourcemap) {
       testStoryCall.loc = node.loc;
-      return testStoryCall;
-    }, "getTestStatementForStory");
-    const storyTestStatements = Object.entries(validStories).map(([exportName, node]) => {
-      if (node === null) {
-        logger4.warn(
-          import_ts_dedent4.dedent`
+    }
+    return testStoryCall;
+  }, "getTestStatementForStory");
+  const getDescribeStatementForStory = /* @__PURE__ */ __name((options) => {
+    const { localName, describeTitle, exportName, tests, node, parentStoryId } = options;
+    const describeBlock = t6.callExpression(vitestDescribeId, [
+      getLiteralWithZeroWidthSpace(describeTitle),
+      t6.arrowFunctionExpression(
+        [],
+        t6.blockStatement([
+          getTestStatementForStory({
+            ...options,
+            testTitle: "base story",
+            overrideSourcemap: false,
+            storyId: parentStoryId
+          }),
+          ...tests.map(({ name: testName, node: testNode, id: storyId }) => {
+            const testStatement = t6.expressionStatement(
+              t6.callExpression(vitestTestId, [
+                t6.stringLiteral(testName),
+                t6.callExpression(testStoryId, [
+                  t6.stringLiteral(exportName),
+                  t6.identifier(localName),
+                  t6.identifier(metaExportName),
+                  t6.arrayExpression([]),
+                  t6.stringLiteral(storyId),
+                  t6.stringLiteral(testName)
+                ])
+              ])
+            );
+            testStatement.loc = testNode.loc;
+            return testStatement;
+          })
+        ])
+      )
+    ]);
+    describeBlock.loc = node.loc;
+    return t6.expressionStatement(describeBlock);
+  }, "getDescribeStatementForStory");
+  const storyTestStatements = Object.entries(validStories).map(([exportName, node]) => {
+    if (node === null) {
+      logger4.warn(
+        import_ts_dedent4.dedent`
             [Storybook]: Could not transform "${exportName}" story into test at "${fileName}".
             Please make sure to define stories in the same file and not re-export stories coming from other files".
           `
-        );
-        return;
-      }
-      const localName = parsed._stories[exportName].localName ?? exportName;
-      const testTitle = parsed._stories[exportName].name ?? exportName;
-      return getTestStatementForStory({ testTitle, localName, exportName, node });
-    }).filter((st) => !!st);
-    const testBlock = t6.ifStatement(isRunningFromThisFileId, t6.blockStatement(storyTestStatements));
-    ast.program.body.push(testBlock);
-    const imports = [
-      t6.importDeclaration(
-        [
-          t6.importSpecifier(vitestTestId, t6.identifier("test")),
-          t6.importSpecifier(vitestExpectId, t6.identifier("expect"))
-        ],
-        t6.stringLiteral("vitest")
-      ),
-      t6.importDeclaration(
-        [
-          t6.importSpecifier(testStoryId, t6.identifier("testStory")),
-          t6.importSpecifier(t6.identifier("convertToFilePath"), t6.identifier("convertToFilePath"))
-        ],
-        t6.stringLiteral("@storybook/addon-vitest/internal/test-utils")
-      )
-    ];
-    ast.program.body.unshift(...imports);
-  }
+      );
+      return;
+    }
+    const localName = parsed._stories[exportName].localName ?? exportName;
+    const testTitle = parsed._stories[exportName].name ?? exportName;
+    const storyId = parsed._stories[exportName].id;
+    const tests = parsed.getStoryTests(exportName);
+    if (tests?.length > 0) {
+      return getDescribeStatementForStory({
+        localName,
+        describeTitle: testTitle,
+        exportName,
+        tests,
+        node,
+        parentStoryId: storyId
+      });
+    }
+    return getTestStatementForStory({
+      testTitle,
+      localName,
+      exportName,
+      node,
+      storyId
+    });
+  }).filter((st) => !!st);
+  const testBlock = t6.ifStatement(isRunningFromThisFileId, t6.blockStatement(storyTestStatements));
+  ast.program.body.push(testBlock);
+  const hasTests = Object.keys(validStories).some(
+    (exportName) => parsed.getStoryTests(exportName).length > 0
+  );
+  const imports = [
+    t6.importDeclaration(
+      [
+        t6.importSpecifier(vitestTestId, t6.identifier("test")),
+        t6.importSpecifier(vitestExpectId, t6.identifier("expect")),
+        ...hasTests ? [t6.importSpecifier(vitestDescribeId, t6.identifier("describe"))] : []
+      ],
+      t6.stringLiteral("vitest")
+    ),
+    t6.importDeclaration(
+      [
+        t6.importSpecifier(testStoryId, t6.identifier("testStory")),
+        t6.importSpecifier(t6.identifier("convertToFilePath"), t6.identifier("convertToFilePath"))
+      ],
+      t6.stringLiteral("@storybook/addon-vitest/internal/test-utils")
+    )
+  ];
+  ast.program.body.unshift(...imports);
   return formatCsf(parsed, { sourceMaps: true, sourceFileName: fileName }, code);
 }
 __name(vitestTransform, "vitestTransform");