storybook 10.2.0-alpha.9 → 10.2.0-beta.0

package/dist/_node-chunks/{chunk-XZ6V3G6J.js → chunk-QL6L57W7.js}

@@ -1,20 +1,20 @@
-import CJS_COMPAT_NODE_URL_3h3bsnbtanf from 'node:url';
-import CJS_COMPAT_NODE_PATH_3h3bsnbtanf from 'node:path';
-import CJS_COMPAT_NODE_MODULE_3h3bsnbtanf from "node:module";
+import CJS_COMPAT_NODE_URL_phceqgr585q from 'node:url';
+import CJS_COMPAT_NODE_PATH_phceqgr585q from 'node:path';
+import CJS_COMPAT_NODE_MODULE_phceqgr585q from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_3h3bsnbtanf.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_3h3bsnbtanf.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_3h3bsnbtanf.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_phceqgr585q.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_phceqgr585q.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_phceqgr585q.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
   require_dist
-} from "./chunk-LRBEW57O.js";
+} from "./chunk-BLGRU6F5.js";
 import {
   __toESM
-} from "./chunk-PZCWRKQE.js";
+} from "./chunk-AXDM43NU.js";
 
 // src/csf-tools/CsfFile.ts
 var import_ts_dedent = __toESM(require_dist(), 1);
@@ -30,6 +30,26 @@ import {
 import { isExportStory, storyNameFromExport, toId, toTestId } from "storybook/internal/csf";
 import { logger } from "storybook/internal/node-logger";
 
+// src/shared/constants/tags.ts
+var Tag = {
+  /** Indicates that autodocs should be generated for this component */
+  AUTODOCS: "autodocs",
+  /** MDX documentation attached to a component's stories file */
+  ATTACHED_MDX: "attached-mdx",
+  /** Standalone MDX documentation not attached to stories */
+  UNATTACHED_MDX: "unattached-mdx",
+  /** Story has a play function */
+  PLAY_FN: "play-fn",
+  /** Story has a test function */
+  TEST_FN: "test-fn",
+  /** Development environment tag */
+  DEV: "dev",
+  /** Test environment tag */
+  TEST: "test",
+  /** Manifest generation tag */
+  MANIFEST: "manifest"
+};
+
 // src/csf-tools/findVarInitialization.ts
 import { types as t } from "storybook/internal/babel";
 var findVarInitialization = (identifier, program) => {
@@ -232,16 +252,16 @@ var formatLocation = (node, fileName) => {
     let self = this;
     if (traverse(this._ast, {
       ExportDefaultDeclaration: {
-        enter(path) {
-          let { node, parent } = path, isVariableReference = t2.isIdentifier(node.declaration) && t2.isProgram(parent);
+        enter(path2) {
+          let { node, parent } = path2, isVariableReference = t2.isIdentifier(node.declaration) && t2.isProgram(parent);
           if (self._options.transformInlineMeta && !isVariableReference && t2.isExpression(node.declaration)) {
-            let metaId = path.scope.generateUidIdentifier("meta");
+            let metaId = path2.scope.generateUidIdentifier("meta");
             self._metaVariableName = metaId.name;
             let nodes = [
               t2.variableDeclaration("const", [t2.variableDeclarator(metaId, node.declaration)]),
               t2.exportDefaultDeclaration(metaId)
             ];
-            nodes.forEach((_node) => _node.loc = path.node.loc), path.replaceWithMultiple(nodes);
+            nodes.forEach((_node) => _node.loc = path2.node.loc), path2.replaceWithMultiple(nodes);
             return;
           }
           let metaNode, decl;
@@ -250,12 +270,12 @@ var formatLocation = (node, fileName) => {
             self._metaVariableName = variableName;
             let isMetaVariable = (declaration) => t2.isIdentifier(declaration.id) && declaration.id.name === variableName;
             self._metaStatementPath = self._file.path.get("body").find(
-              (path2) => path2.isVariableDeclaration() && path2.node.declarations.some(isMetaVariable)
+              (path3) => path3.isVariableDeclaration() && path3.node.declarations.some(isMetaVariable)
             ), self._metaStatement = self._metaStatementPath?.node, decl = (self?._metaStatement?.declarations || []).find(
               isMetaVariable
             )?.init;
           } else
-            self._metaStatement = node, self._metaStatementPath = path, decl = node.declaration;
+            self._metaStatement = node, self._metaStatementPath = path2, decl = node.declaration;
           if (t2.isObjectExpression(decl) ? metaNode = decl : /* export default { ... } as Meta<...> */ /* export default { ... } satisfies Meta<...> */ (t2.isTSAsExpression(decl) || t2.isTSSatisfiesExpression(decl)) && t2.isObjectExpression(decl.expression) ? metaNode = decl.expression : (
             // export default { ... } satisfies Meta as Meta<...>
             t2.isTSAsExpression(decl) && t2.isTSSatisfiesExpression(decl.expression) && t2.isObjectExpression(decl.expression.expression) && (metaNode = decl.expression.expression)
@@ -265,12 +285,12 @@ var formatLocation = (node, fileName) => {
               self._metaStatement,
               self._options.fileName
             );
-          self._metaPath = path;
+          self._metaPath = path2;
         }
       },
       ExportNamedDeclaration: {
-        enter(path) {
-          let { node, parent } = path, declaration = path.get("declaration"), declarations;
+        enter(path2) {
+          let { node, parent } = path2, declaration = path2.get("declaration"), declarations;
           declaration.isVariableDeclaration() ? declarations = declaration.get("declarations").filter((d) => d.isVariableDeclarator()) : declaration.isFunctionDeclaration() && (declarations = [declaration]), declarations ? declarations.forEach((declPath) => {
             let decl = declPath.node, id = declPath.node.id;
             if (t2.isIdentifier(id)) {
@@ -279,7 +299,7 @@ var formatLocation = (node, fileName) => {
                 self._namedExportsOrder = parseExportsOrder(declPath.node.init);
                 return;
               }
-              self._storyExports[exportName] = decl, self._storyDeclarationPath[exportName] = declPath, self._storyPaths[exportName] = path, self._storyStatements[exportName] = node;
+              self._storyExports[exportName] = decl, self._storyDeclarationPath[exportName] = declPath, self._storyPaths[exportName] = path2, self._storyStatements[exportName] = node;
               let name = storyNameFromExport(exportName);
               self._storyAnnotations[exportName] ? logger.warn(
                 `Unexpected annotations for "${exportName}" before story declaration`
@@ -351,7 +371,7 @@ var formatLocation = (node, fileName) => {
                 let annotations = {}, storyNode = decl;
                 t2.isObjectExpression(storyNode) && storyNode.properties.forEach((p) => {
                   t2.isIdentifier(p.key) && (annotations[p.key.name] = p.value);
-                }), self._storyAnnotations[exportName] = annotations, self._storyStatements[exportName] = decl, self._storyPaths[exportName] = path, self._stories[exportName] = {
+                }), self._storyAnnotations[exportName] = annotations, self._storyStatements[exportName] = decl, self._storyPaths[exportName] = path2, self._stories[exportName] = {
                   id: "FIXME",
                   name: exportName,
                   localName,
@@ -393,31 +413,34 @@ var formatLocation = (node, fileName) => {
         }
       },
       CallExpression: {
-        enter(path) {
-          let { node } = path, { callee } = node;
+        enter(path2) {
+          let { node } = path2, { callee } = node;
           if (t2.isIdentifier(callee) && callee.name === "storiesOf")
             throw new Error(import_ts_dedent.dedent`
               Unexpected \`storiesOf\` usage: ${formatLocation(node, self._options.fileName)}.
 
               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) {
-            let configParent = path.scope.getBinding(callee.object.name)?.path?.parentPath?.node;
-            if (t2.isImportDeclaration(configParent))
-              if (isValidPreviewPath(configParent.source.value)) {
-                self._metaIsFactory = !0;
-                let metaDeclarator = path.findParent(
-                  (p) => p.isVariableDeclarator()
-                );
-                self._metaVariableName = t2.isIdentifier(metaDeclarator.node.id) ? metaDeclarator.node.id.name : callee.property.name;
-                let metaNode = node.arguments[0];
-                self._parseMeta(metaNode, self._ast.program);
-              } else
-                throw new BadMetaError(
-                  "meta() factory must be imported from .storybook/preview configuration",
-                  configParent,
-                  self._options.fileName
-                );
+          if (t2.isMemberExpression(callee) && t2.isIdentifier(callee.property) && callee.property.name === "meta" && node.arguments.length > 0) {
+            let rootObject = callee.object;
+            if (t2.isCallExpression(rootObject) && t2.isMemberExpression(rootObject.callee) && (rootObject = rootObject.callee.object), t2.isIdentifier(rootObject)) {
+              let configParent = path2.scope.getBinding(rootObject.name)?.path?.parentPath?.node;
+              if (t2.isImportDeclaration(configParent))
+                if (isValidPreviewPath(configParent.source.value)) {
+                  self._metaIsFactory = !0;
+                  let metaDeclarator = path2.findParent(
+                    (p) => p.isVariableDeclarator()
+                  );
+                  self._metaVariableName = t2.isIdentifier(metaDeclarator.node.id) ? metaDeclarator.node.id.name : callee.property.name;
+                  let metaNode = node.arguments[0];
+                  self._parseMeta(metaNode, self._ast.program);
+                } else
+                  throw new BadMetaError(
+                    "meta() factory must be imported from .storybook/preview configuration",
+                    configParent,
+                    self._options.fileName
+                  );
+            }
           }
         }
       },
@@ -433,7 +456,7 @@ var formatLocation = (node, fileName) => {
     }), !self._meta)
       throw new NoMetaError("missing default export", self._ast, self._options.fileName);
     let entries = Object.entries(self._stories);
-    if (self._meta.title = this._options.makeTitle(self._meta?.title), self._metaAnnotations.play && (self._meta.tags = [...self._meta.tags || [], "play-fn"]), self._stories = entries.reduce(
+    if (self._meta.title = this._options.makeTitle(self._meta?.title), self._metaAnnotations.play && (self._meta.tags = [...self._meta.tags || [], Tag.PLAY_FN]), self._stories = entries.reduce(
       (acc, [key, story]) => {
         if (!isExportStory(key, self._meta))
           return acc;
@@ -444,14 +467,14 @@ var formatLocation = (node, fileName) => {
           let node = t2.isIdentifier(tags) ? findVarInitialization(tags.name, this._ast.program) : tags;
           acc[key].tags = parseTags(node);
         }
-        play && (acc[key].tags = [...acc[key].tags || [], "play-fn"]);
+        play && (acc[key].tags = [...acc[key].tags || [], Tag.PLAY_FN]);
         let stats = acc[key].__stats;
         ["play", "render", "loaders", "beforeEach", "globals", "tags"].forEach((annotation) => {
           stats[annotation] = !!storyAnnotations[annotation] || !!self._metaAnnotations[annotation];
         });
         let storyExport = self.getStoryExport(key);
         stats.storyFn = !!(t2.isArrowFunctionExpression(storyExport) || t2.isFunctionDeclaration(storyExport)), stats.mount = hasMount(storyAnnotations.play ?? self._metaAnnotations.play), stats.moduleMock = !!self.imports.find((fname) => isModuleMock(fname));
-        let storyNode = self._storyStatements[key], storyTests = self._tests.filter((t7) => t7.parent.node === storyNode);
+        let storyNode = self._storyStatements[key], storyTests = self._tests.filter((t8) => t8.parent.node === storyNode);
         return storyTests.length > 0 && (stats.tests = !0, storyTests.forEach((test) => {
           test.id = toTestId(id, test.name);
         })), acc;
@@ -480,7 +503,7 @@ var formatLocation = (node, fileName) => {
   }
   getStoryTests(story) {
     let storyNode = typeof story == "string" ? this._storyStatements[story] : story;
-    return storyNode ? this._tests.filter((t7) => t7.parent.node === storyNode) : [];
+    return storyNode ? this._tests.filter((t8) => t8.parent.node === storyNode) : [];
   }
   get indexInputs() {
     let { fileName } = this._options;
@@ -518,10 +541,10 @@ var formatLocation = (node, fileName) => {
           tags: [
             ...storyInput.tags,
             // this tag comes before test tags so users can invert if they like
-            "!autodocs",
+            `!${Tag.AUTODOCS}`,
             ...test.tags,
             // this tag comes after test tags so users can't change it
-            "test-fn"
+            Tag.TEST_FN
           ],
           __id: test.id
         });
@@ -567,35 +590,35 @@ var getCsfParsingErrorMessage = ({
   node
 }) => import_ts_dedent2.dedent`
       CSF Parsing error: Expected '${expectedType}' but found '${foundType}' instead in '${node?.type}'.
-    `, propKey = (p) => t3.isIdentifier(p.key) ? p.key.name : t3.isStringLiteral(p.key) ? p.key.value : null, _getPath = (path, node) => {
-  if (path.length === 0)
+    `, propKey = (p) => t3.isIdentifier(p.key) ? p.key.name : t3.isStringLiteral(p.key) ? p.key.value : null, _getPath = (path2, node) => {
+  if (path2.length === 0)
     return node;
   if (t3.isObjectExpression(node)) {
-    let [first, ...rest] = path, field = node.properties.find((p) => propKey(p) === first);
+    let [first, ...rest] = path2, field = node.properties.find((p) => propKey(p) === first);
     if (field)
       return _getPath(rest, field.value);
   }
-}, _getPathProperties = (path, node) => {
-  if (path.length === 0) {
+}, _getPathProperties = (path2, node) => {
+  if (path2.length === 0) {
     if (t3.isObjectExpression(node))
       return node.properties;
     throw new Error("Expected object expression");
   }
   if (t3.isObjectExpression(node)) {
-    let [first, ...rest] = path, field = node.properties.find((p) => propKey(p) === first);
+    let [first, ...rest] = path2, field = node.properties.find((p) => propKey(p) === first);
     if (field)
       return rest.length === 0 ? node.properties : _getPathProperties(rest, field.value);
   }
 }, _findVarDeclarator = (identifier, program) => {
   let declarator = null, declarations = null;
   return program.body.find((node) => (t3.isVariableDeclaration(node) ? declarations = node.declarations : t3.isExportNamedDeclaration(node) && t3.isVariableDeclaration(node.declaration) && (declarations = node.declaration.declarations), declarations && declarations.find((decl) => t3.isVariableDeclarator(decl) && t3.isIdentifier(decl.id) && decl.id.name === identifier ? (declarator = decl, !0) : !1))), declarator;
-}, _findVarInitialization = (identifier, program) => _findVarDeclarator(identifier, program)?.init, _makeObjectExpression = (path, value) => {
-  if (path.length === 0)
+}, _findVarInitialization = (identifier, program) => _findVarDeclarator(identifier, program)?.init, _makeObjectExpression = (path2, value) => {
+  if (path2.length === 0)
     return value;
-  let [first, ...rest] = path, innerExpression = _makeObjectExpression(rest, value);
+  let [first, ...rest] = path2, innerExpression = _makeObjectExpression(rest, value);
   return t3.objectExpression([t3.objectProperty(t3.identifier(first), innerExpression)]);
-}, _updateExportNode = (path, expr, existing) => {
-  let [first, ...rest] = path, existingField = existing.properties.find(
+}, _updateExportNode = (path2, expr, existing) => {
+  let [first, ...rest] = path2, existingField = existing.properties.find(
     (p) => propKey(p) === first
   );
   existingField ? t3.isObjectExpression(existingField.value) && rest.length > 0 ? _updateExportNode(rest, expr, existingField.value) : existingField.value = _makeObjectExpression(rest, expr) : existing.properties.push(
@@ -709,31 +732,31 @@ var getCsfParsingErrorMessage = ({
       }
     }), self;
   }
-  getFieldNode(path) {
-    let [root, ...rest] = path, exported = this._exports[root];
+  getFieldNode(path2) {
+    let [root, ...rest] = path2, exported = this._exports[root];
     if (exported)
       return _getPath(rest, exported);
   }
-  getFieldProperties(path) {
-    let [root, ...rest] = path, exported = this._exports[root];
+  getFieldProperties(path2) {
+    let [root, ...rest] = path2, exported = this._exports[root];
     if (exported)
       return _getPathProperties(rest, exported);
   }
-  getFieldValue(path) {
-    let node = this.getFieldNode(path);
+  getFieldValue(path2) {
+    let node = this.getFieldNode(path2);
     if (node) {
       let { code } = generate2(node, {});
       return (0, eval)(`(() => (${code}))()`);
     }
   }
-  getSafeFieldValue(path) {
+  getSafeFieldValue(path2) {
     try {
-      return this.getFieldValue(path);
+      return this.getFieldValue(path2);
     } catch {
     }
   }
-  setFieldNode(path, expr) {
-    let [first, ...rest] = path, exportNode = this._exports[first];
+  setFieldNode(path2, expr) {
+    let [first, ...rest] = path2, exportNode = this._exports[first];
     if (this._exportsObject) {
       let existingProp = this._exportsObject.properties.find((p) => propKey(p) === first);
       if (existingProp && t3.isIdentifier(existingProp.value)) {
@@ -743,7 +766,7 @@ var getCsfParsingErrorMessage = ({
           return;
         }
       }
-      _updateExportNode(path, expr, this._exportsObject), this._exports[path[0]] = expr;
+      _updateExportNode(path2, expr, this._exportsObject), this._exports[path2[0]] = expr;
       return;
     }
     if (exportNode && t3.isObjectExpression(exportNode) && rest.length > 0) {
@@ -755,13 +778,13 @@ var getCsfParsingErrorMessage = ({
       _updateExportNode(rest, expr, varDecl.init);
       return;
     }
-    if (exportNode && rest.length === 0 && this._exportDecls[path[0]]) {
-      let decl = this._exportDecls[path[0]];
+    if (exportNode && rest.length === 0 && this._exportDecls[path2[0]]) {
+      let decl = this._exportDecls[path2[0]];
       t3.isVariableDeclarator(decl) && (decl.init = _makeObjectExpression([], expr));
     } else {
       if (this.hasDefaultExport)
         throw new Error(
-          `Could not set the "${path.join(
+          `Could not set the "${path2.join(
             "."
           )}" field as the default export is not an object in this file.`
         );
@@ -784,8 +807,8 @@ var getCsfParsingErrorMessage = ({
    *
    * @returns The name of a node in a given path, supporting the following formats:
    */
-  getNameFromPath(path) {
-    let node = this.getFieldNode(path);
+  getNameFromPath(path2) {
+    let node = this.getFieldNode(path2);
     if (node)
       return this._getPresetValue(node, "name");
   }
@@ -802,8 +825,8 @@ var getCsfParsingErrorMessage = ({
    * getNamesFromPath(['addons']);
    * ```
    */
-  getNamesFromPath(path) {
-    let node = this.getFieldNode(path);
+  getNamesFromPath(path2) {
+    let node = this.getFieldNode(path2);
     if (!node)
       return;
     let pathNames = [];
@@ -834,68 +857,68 @@ var getCsfParsingErrorMessage = ({
       );
     return value;
   }
-  removeField(path) {
+  removeField(path2) {
     let removeProperty = (properties2, prop) => {
       let index = properties2.findIndex(
         (p) => t3.isIdentifier(p.key) && p.key.name === prop || t3.isStringLiteral(p.key) && p.key.value === prop
       );
       index >= 0 && properties2.splice(index, 1);
     };
-    if (path.length === 1) {
+    if (path2.length === 1) {
       let removedRootProperty = !1;
       if (this._ast.program.body.forEach((node) => {
         if (t3.isExportNamedDeclaration(node) && t3.isVariableDeclaration(node.declaration)) {
           let decl = node.declaration.declarations[0];
-          t3.isIdentifier(decl.id) && decl.id.name === path[0] && (this._ast.program.body.splice(this._ast.program.body.indexOf(node), 1), removedRootProperty = !0);
+          t3.isIdentifier(decl.id) && decl.id.name === path2[0] && (this._ast.program.body.splice(this._ast.program.body.indexOf(node), 1), removedRootProperty = !0);
         }
         if (t3.isExportDefaultDeclaration(node)) {
           let resolved = this._resolveDeclaration(node.declaration);
           if (t3.isObjectExpression(resolved)) {
             let properties2 = resolved.properties;
-            removeProperty(properties2, path[0]), removedRootProperty = !0;
+            removeProperty(properties2, path2[0]), removedRootProperty = !0;
           }
         }
         if (t3.isExpressionStatement(node) && t3.isAssignmentExpression(node.expression) && t3.isMemberExpression(node.expression.left) && t3.isIdentifier(node.expression.left.object) && node.expression.left.object.name === "module" && t3.isIdentifier(node.expression.left.property) && node.expression.left.property.name === "exports" && t3.isObjectExpression(node.expression.right)) {
           let properties2 = node.expression.right.properties;
-          removeProperty(properties2, path[0]), removedRootProperty = !0;
+          removeProperty(properties2, path2[0]), removedRootProperty = !0;
         }
       }), removedRootProperty)
         return;
     }
-    let properties = this.getFieldProperties(path);
+    let properties = this.getFieldProperties(path2);
     if (properties) {
-      let lastPath = path.at(-1);
+      let lastPath = path2.at(-1);
       removeProperty(properties, lastPath);
     }
   }
-  appendValueToArray(path, value) {
+  appendValueToArray(path2, value) {
     let node = this.valueToNode(value);
-    node && this.appendNodeToArray(path, node);
+    node && this.appendNodeToArray(path2, node);
   }
-  appendNodeToArray(path, node) {
-    let current = this.getFieldNode(path);
+  appendNodeToArray(path2, node) {
+    let current = this.getFieldNode(path2);
     if (!current)
-      this.setFieldNode(path, t3.arrayExpression([node]));
+      this.setFieldNode(path2, t3.arrayExpression([node]));
     else if (t3.isArrayExpression(current))
       current.elements.push(node);
     else
-      throw new Error(`Expected array at '${path.join(".")}', got '${current.type}'`);
+      throw new Error(`Expected array at '${path2.join(".")}', got '${current.type}'`);
   }
   /**
    * Specialized helper to remove addons or other array entries that can either be strings or
    * objects with a name property.
    */
-  removeEntryFromArray(path, value) {
-    let current = this.getFieldNode(path);
+  removeEntryFromArray(path2, value) {
+    let current = this.getFieldNode(path2);
     if (current)
       if (t3.isArrayExpression(current)) {
         let index = current.elements.findIndex((element) => t3.isStringLiteral(element) ? element.value === value : t3.isObjectExpression(element) ? this._getPresetValue(element, "name") === value : this._getPnpWrappedValue(element) === value);
         if (index >= 0)
           current.elements.splice(index, 1);
         else
-          throw new Error(`Could not find '${value}' in array at '${path.join(".")}'`);
+          throw new Error(`Could not find '${value}' in array at '${path2.join(".")}'`);
       } else
-        throw new Error(`Expected array at '${path.join(".")}', got '${current.type}'`);
+        throw new Error(`Expected array at '${path2.join(".")}', got '${current.type}'`);
   }
   _inferQuotes() {
     if (!this._quotes) {
@@ -922,11 +945,11 @@ var getCsfParsingErrorMessage = ({
       valueNode = t3.valueToNode(value);
     return valueNode;
   }
-  setFieldValue(path, value) {
+  setFieldValue(path2, value) {
     let valueNode = this.valueToNode(value);
     if (!valueNode)
       throw new Error(`Unexpected value ${JSON.stringify(value)}`);
-    this.setFieldNode(path, valueNode);
+    this.setFieldNode(path2, valueNode);
   }
   getBodyDeclarations() {
     return this._ast.program.body;
@@ -1290,14 +1313,14 @@ var enrichCsfStory = (csf, csfSource, key, options) => {
     );
     csf._ast.program.body.push(addParameter);
   }
-}, addComponentDescription = (node, path, value) => {
-  if (!path.length) {
+}, addComponentDescription = (node, path2, value) => {
+  if (!path2.length) {
     node.properties.find(
       (p) => t5.isObjectProperty(p) && t5.isIdentifier(p.key) && p.key.name === "component"
     ) || node.properties.unshift(value);
     return;
   }
-  let [first, ...rest] = path, existing = node.properties.find(
+  let [first, ...rest] = path2, existing = node.properties.find(
     (p) => t5.isObjectProperty(p) && t5.isIdentifier(p.key) && p.key.name === first && t5.isObjectExpression(p.value)
   ), subNode;
   existing ? subNode = existing.value : (subNode = t5.objectExpression([]), node.properties.push(t5.objectProperty(t5.identifier(first), subNode))), addComponentDescription(subNode, rest, value);
@@ -1324,7 +1347,7 @@ var enrichCsfStory = (csf, csfSource, key, options) => {
 `) : "";
 
 // src/csf-tools/index.ts
-import { babelParse as babelParse4 } from "storybook/internal/babel";
+import { babelParse as babelParse5 } from "storybook/internal/babel";
 
 // src/csf-tools/vitest-plugin/transformer.ts
 var import_ts_dedent4 = __toESM(require_dist(), 1);
@@ -1333,6 +1356,38 @@ import { getStoryTitle } from "storybook/internal/common";
 import { combineTags } from "storybook/internal/csf";
 import { logger as logger4 } from "storybook/internal/node-logger";
 var isValidTest = (storyTags, tagsFilter) => !(tagsFilter.include.length && !tagsFilter.include.some((tag) => storyTags?.includes(tag)) || tagsFilter.exclude.some((tag) => storyTags?.includes(tag))), DOUBLE_SPACES = "  ", getLiteralWithZeroWidthSpace = (testTitle) => t6.stringLiteral(`${testTitle}${DOUBLE_SPACES}`);
+function createTestGuardDeclaration(scope, expectId, convertToFilePathId) {
+  let isRunningFromThisFileId = scope.generateUidIdentifier("isRunningFromThisFile"), testPathProperty = t6.memberExpression(
+    t6.callExpression(t6.memberExpression(expectId, t6.identifier("getState")), []),
+    t6.identifier("testPath")
+  ), filePathProperty = t6.memberExpression(
+    t6.memberExpression(t6.identifier("globalThis"), t6.identifier("__vitest_worker__")),
+    t6.identifier("filepath")
+  ), 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
+  ), includesCall = t6.callExpression(
+    t6.memberExpression(
+      t6.callExpression(convertToFilePathId, [
+        t6.memberExpression(
+          t6.memberExpression(t6.identifier("import"), t6.identifier("meta")),
+          t6.identifier("url")
+        )
+      ]),
+      t6.identifier("includes")
+    ),
+    [nullishCoalescingExpression]
+  );
+  return {
+    declaration: t6.variableDeclaration("const", [
+      t6.variableDeclarator(isRunningFromThisFileId, includesCall)
+    ]),
+    identifier: isRunningFromThisFileId
+  };
+}
 async function vitestTransform({
   code,
   fileName,
@@ -1397,37 +1452,13 @@ Please make sure you have a default export with the meta object. If you are usin
     ];
     return ast.program.body.unshift(...imports2), formatCsf(parsed, { sourceMaps: !0, sourceFileName: fileName }, code);
   }
-  let vitestExpectId = parsed._file.path.scope.generateUidIdentifier("expect"), testStoryId = parsed._file.path.scope.generateUidIdentifier("testStory"), skipTagsId = t6.identifier(JSON.stringify(tagsFilter.skip));
-  function getTestGuardDeclaration() {
-    let isRunningFromThisFileId2 = parsed._file.path.scope.generateUidIdentifier("isRunningFromThisFile"), testPathProperty = t6.memberExpression(
-      t6.callExpression(t6.memberExpression(vitestExpectId, t6.identifier("getState")), []),
-      t6.identifier("testPath")
-    ), filePathProperty = t6.memberExpression(
-      t6.memberExpression(t6.identifier("globalThis"), t6.identifier("__vitest_worker__")),
-      t6.identifier("filepath")
-    ), 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
-    ), 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]
-    );
-    return { isRunningFromThisFileDeclaration: t6.variableDeclaration("const", [
-      t6.variableDeclarator(isRunningFromThisFileId2, includesCall)
-    ]), isRunningFromThisFileId: isRunningFromThisFileId2 };
-  }
-  let { isRunningFromThisFileDeclaration, isRunningFromThisFileId } = getTestGuardDeclaration();
+  let vitestExpectId = parsed._file.path.scope.generateUidIdentifier("expect"), testStoryId = parsed._file.path.scope.generateUidIdentifier("testStory"), skipTagsId = t6.identifier(JSON.stringify(tagsFilter.skip)), componentPathLiteral = parsed._rawComponentPath ? t6.stringLiteral(parsed._rawComponentPath) : null, componentNameLiteral = null;
+  parsed._componentImportSpecifier && (t6.isImportSpecifier(parsed._componentImportSpecifier) || t6.isImportDefaultSpecifier(parsed._componentImportSpecifier)) && (componentNameLiteral = t6.stringLiteral(parsed._componentImportSpecifier.local.name));
+  let { declaration: isRunningFromThisFileDeclaration, identifier: isRunningFromThisFileId } = createTestGuardDeclaration(
+    parsed._file.path.scope,
+    vitestExpectId,
+    t6.identifier("convertToFilePath")
+  );
   ast.program.body.push(isRunningFromThisFileDeclaration);
   let getTestStatementForStory = ({
     localName,
@@ -1437,16 +1468,18 @@ Please make sure you have a default export with the meta object. If you are usin
     overrideSourcemap = !0,
     storyId
   }) => {
+    let objectProperties = [
+      t6.objectProperty(t6.identifier("exportName"), t6.stringLiteral(exportName)),
+      t6.objectProperty(t6.identifier("story"), t6.identifier(localName)),
+      t6.objectProperty(t6.identifier("meta"), t6.identifier(metaExportName)),
+      t6.objectProperty(t6.identifier("skipTags"), skipTagsId),
+      t6.objectProperty(t6.identifier("storyId"), t6.stringLiteral(storyId))
+    ];
+    componentPathLiteral && objectProperties.push(t6.objectProperty(t6.identifier("componentPath"), componentPathLiteral)), componentNameLiteral && objectProperties.push(t6.objectProperty(t6.identifier("componentName"), componentNameLiteral));
     let 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)
-        ])
+        t6.callExpression(testStoryId, [t6.objectExpression(objectProperties)])
       ])
     );
     return overrideSourcemap && (testStoryCall.loc = node.loc), testStoryCall;
@@ -1463,17 +1496,24 @@ Please make sure you have a default export with the meta object. If you are usin
             storyId: parentStoryId
           }),
           ...tests.map(({ name: testName, node: testNode, id: storyId }) => {
+            let objectProperties = [
+              t6.objectProperty(t6.identifier("exportName"), t6.stringLiteral(exportName)),
+              t6.objectProperty(t6.identifier("story"), t6.identifier(localName)),
+              t6.objectProperty(t6.identifier("meta"), t6.identifier(metaExportName)),
+              t6.objectProperty(t6.identifier("skipTags"), t6.arrayExpression([])),
+              t6.objectProperty(t6.identifier("storyId"), t6.stringLiteral(storyId))
+            ];
+            componentPathLiteral && objectProperties.push(
+              t6.objectProperty(t6.identifier("componentPath"), componentPathLiteral)
+            ), componentNameLiteral && objectProperties.push(
+              t6.objectProperty(t6.identifier("componentName"), componentNameLiteral)
+            ), testName && objectProperties.push(
+              t6.objectProperty(t6.identifier("testName"), t6.stringLiteral(testName))
+            );
             let 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)
-                ])
+                t6.callExpression(testStoryId, [t6.objectExpression(objectProperties)])
               ])
             );
             return testStatement.loc = testNode.loc, testStatement;
@@ -1531,7 +1571,354 @@ Please make sure you have a default export with the meta object. If you are usin
   return ast.program.body.unshift(...imports), formatCsf(parsed, { sourceMaps: !0, sourceFileName: fileName }, code);
 }
 
+// src/csf-tools/vitest-plugin/component-transformer.ts
+import path from "node:path";
+import {
+  BabelFileClass as BabelFileClass2,
+  babelParse as babelParse4,
+  generate as generate5,
+  types as t7,
+  traverse as traverse4
+} from "storybook/internal/babel";
+
+// src/core-server/utils/get-dummy-args-from-argtypes.ts
+var STORYBOOK_FN_PLACEHOLDER = "[[STORYBOOK_FN_PLACEHOLDER]]";
+function generateDummyArgsFromArgTypes(argTypes, options = {}) {
+  let required = {}, optional = {};
+  for (let [propName, argType] of Object.entries(argTypes)) {
+    let isRequired = argType.type && typeof argType.type == "object" && argType.type.required, dummyValue;
+    if (typeof argType.type == "string") {
+      let sbType = { name: argType.type };
+      dummyValue = generateDummyValueFromSBType(sbType, propName, options);
+    } else argType.type && typeof argType.type == "object" ? dummyValue = generateDummyValueFromSBType(argType.type, propName, options) : dummyValue = void 0;
+    isRequired ? required[propName] = dummyValue : optional[propName] = dummyValue;
+  }
+  return { required, optional };
+}
+function tokenize(name) {
+  return name ? name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-]+/g, " ").split(" ").map((t8) => t8.toLowerCase()).filter(Boolean) : [];
+}
+function hasAny(tokens, set) {
+  return tokens.some((t8) => set.has(t8));
+}
+var URL_TOKENS = /* @__PURE__ */ new Set(["url", "href", "link"]), IMAGE_TOKENS = /* @__PURE__ */ new Set(["image", "img", "photo", "avatar", "logo"]), EMAIL_TOKENS = /* @__PURE__ */ new Set(["email", "e-mail", "mail"]), PHONE_TOKENS = /* @__PURE__ */ new Set(["phone", "tel", "telephone", "mobile", "cell"]), COLOR_TOKENS = /* @__PURE__ */ new Set(["color", "background", "bg"]), DATE_TOKENS = /* @__PURE__ */ new Set(["date", "at", "time", "timestamp"]), NEGATIVE_IMAGE_TOKENS = /* @__PURE__ */ new Set([
+  "size",
+  "width",
+  "height",
+  "ratio",
+  "count",
+  "status",
+  "loading",
+  "config",
+  "options",
+  "variant"
+]);
+function getMostLikelyTypeFromTokens(tokens) {
+  let score = {};
+  for (let token of tokens)
+    IMAGE_TOKENS.has(token) && (score.image = (score.image ?? 0) + 3), URL_TOKENS.has(token) && (score.url = (score.url ?? 0) + 2), EMAIL_TOKENS.has(token) && (score.email = (score.email ?? 0) + 3), PHONE_TOKENS.has(token) && (score.phone = (score.phone ?? 0) + 3);
+  hasAny(tokens, NEGATIVE_IMAGE_TOKENS) && (score.image = (score.image ?? 0) - 4);
+  let best = null, bestScore = 0;
+  for (let [kind, value] of Object.entries(score))
+    value > bestScore && (bestScore = value, best = kind);
+  return best;
+}
+function normalizeStringLiteral(value) {
+  return typeof value != "string" ? value : value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'") ? value.slice(1, -1) : value;
+}
+function generateDummyValueFromSBType(sbType, propName, options) {
+  switch (sbType.name) {
+    case "boolean":
+      return !0;
+    case "number":
+      return 0;
+    case "string": {
+      let name = propName ?? "", tokens = tokenize(name);
+      if (hasAny(tokens, COLOR_TOKENS))
+        return "#ff4785";
+      if (hasAny(tokens, DATE_TOKENS))
+        return (/* @__PURE__ */ new Date()).toLocaleDateString();
+      let mostLikelyType = getMostLikelyTypeFromTokens(tokens);
+      if (options?.skipUrlGeneration && (mostLikelyType === "image" || mostLikelyType === "url"))
+        return name;
+      switch (mostLikelyType) {
+        case "image":
+          return "https://placehold.co/600x400?text=Storybook";
+        case "url":
+          return "https://example.com";
+        case "email":
+          return "storybook@example.com";
+        case "phone":
+          return "1234567890";
+        default:
+          return name ?? "Hello world";
+      }
+    }
+    case "date":
+      return /* @__PURE__ */ new Date();
+    case "node":
+      return propName ?? "Hello world";
+    case "function":
+      return STORYBOOK_FN_PLACEHOLDER;
+    case "literal":
+      return normalizeStringLiteral(sbType.value);
+    case "object": {
+      let result = {};
+      for (let [key, valueType] of Object.entries(sbType.value))
+        result[key] = generateDummyValueFromSBType(valueType, key, options);
+      return result;
+    }
+    case "union": {
+      if (!sbType.value?.length)
+        return "";
+      let literalType = sbType.value.find((t8) => t8.name === "literal");
+      return literalType?.name === "literal" ? normalizeStringLiteral(literalType.value) : generateDummyValueFromSBType(sbType.value[0], propName, options);
+    }
+    case "array":
+      return sbType.value.name === "other" ? [] : [generateDummyValueFromSBType(sbType.value, propName, options)];
+    case "tuple":
+      return sbType.value.map((el) => generateDummyValueFromSBType(el, void 0, options));
+    case "enum":
+      return sbType.value[0] ?? propName;
+    case "intersection": {
+      let objectTypes = sbType.value.filter((t8) => t8.name === "object");
+      if (objectTypes.length > 0) {
+        let result = {};
+        return objectTypes.forEach((objType) => {
+          objType.name === "object" && Object.entries(objType.value).forEach(([key, type]) => {
+            result[key] = generateDummyValueFromSBType(type, key, options);
+          });
+        }), result;
+      }
+      return {};
+    }
+    case "other": {
+      let value = sbType.value;
+      return value?.startsWith("React") || value?.includes("Event") || value?.includes("Element") ? STORYBOOK_FN_PLACEHOLDER : value === "null" ? null : value === "void" || value === "undefined" ? void 0 : value ?? propName;
+    }
+  }
+}
+
+// src/csf-tools/vitest-plugin/component-transformer.ts
+var VITEST_IMPORT_SOURCE = "vitest", TEST_UTILS_IMPORT_SOURCE = "@storybook/addon-vitest/internal/test-utils", STORYBOOK_TEST_IMPORT_SOURCE = "storybook/test", sanitizeIdentifier = (value) => value.replace(/[^a-zA-Z0-9_$]+/g, "") || "Component", createComponentNameFromFileName = (fileName) => {
+  if (!fileName)
+    return "Component";
+  let basename = path.basename(fileName, path.extname(fileName));
+  return sanitizeIdentifier(basename);
+}, containsJsxNode = (valuePath) => {
+  if (!valuePath?.node)
+    return !1;
+  let found = !1;
+  return valuePath.traverse({
+    JSXElement(path2) {
+      found = !0, path2.stop();
+    },
+    JSXFragment(path2) {
+      found = !0, path2.stop();
+    }
+  }), found;
+}, unwrapExpression = (node) => node ? t7.isTSAsExpression(node) || t7.isTSSatisfiesExpression(node) ? unwrapExpression(node.expression) : node : null, dedupeImports = (program, source, specifiers) => {
+  let existing = program.body.find(
+    (node) => t7.isImportDeclaration(node) && node.source.value === source
+  );
+  if (existing) {
+    specifiers.forEach((specifier) => {
+      existing.specifiers.every(
+        (existingSpecifier) => !t7.isImportSpecifier(existingSpecifier) || existingSpecifier.local.name !== specifier.local.name
+      ) && existing.specifiers.push(specifier);
+    });
+    return;
+  }
+  program.body.unshift(t7.importDeclaration(specifiers, t7.stringLiteral(source)));
+}, collectComponentExports = (program, fileName) => {
+  let components = [], addComponent = (exportedName, localIdentifier, valuePath) => {
+    !valuePath || !valuePath.node || !unwrapExpression(valuePath.node) || containsJsxNode(valuePath) && components.push({ exportedName, localIdentifier });
+  };
+  return traverse4(program, {
+    ExportNamedDeclaration(path2) {
+      let { node } = path2;
+      if (node.source)
+        return;
+      let declarationPath = path2.get("declaration");
+      if (declarationPath.isVariableDeclaration())
+        declarationPath.get("declarations").forEach((declPath) => {
+          if (!declPath.isVariableDeclarator())
+            return;
+          let id = declPath.node.id;
+          if (!t7.isIdentifier(id))
+            return;
+          let initPath = declPath.get("init");
+          addComponent(id.name, id, initPath);
+        });
+      else if (declarationPath.isFunctionDeclaration() && declarationPath.node.id) {
+        let declarationId = declarationPath.node.id;
+        t7.isIdentifier(declarationId) && addComponent(declarationId.name, declarationId, declarationPath);
+      } else if (declarationPath.isClassDeclaration() && declarationPath.node.id) {
+        let declarationId = declarationPath.node.id;
+        t7.isIdentifier(declarationId) && addComponent(declarationId.name, declarationId, declarationPath);
+      }
+      path2.get("specifiers").forEach((specifierPath) => {
+        if (!specifierPath.isExportSpecifier())
+          return;
+        let { local, exported } = specifierPath.node;
+        if (!t7.isIdentifier(local) || !t7.isIdentifier(exported))
+          return;
+        let binding = specifierPath.scope.getBinding(local.name);
+        if (!binding)
+          return;
+        let bindingPath = binding.path, localIdentifier = binding.identifier;
+        if (t7.isIdentifier(localIdentifier)) {
+          if (bindingPath.isVariableDeclarator())
+            addComponent(exported.name, localIdentifier, bindingPath.get("init"));
+          else if (bindingPath.isFunctionDeclaration() || bindingPath.isClassDeclaration()) {
+            let bindingNodeId = bindingPath.node.id;
+            t7.isIdentifier(bindingNodeId) && addComponent(exported.name, localIdentifier, bindingPath);
+          }
+        }
+      });
+    },
+    ExportDefaultDeclaration(path2) {
+      let { node } = path2, declaration = node.declaration;
+      if (t7.isFunctionExpression(declaration) || t7.isArrowFunctionExpression(declaration) || t7.isClassExpression(declaration)) {
+        let identifierName = createComponentNameFromFileName(fileName), identifier = path2.scope.generateUidIdentifier(identifierName), variableDeclaration = t7.variableDeclaration("const", [
+          t7.variableDeclarator(identifier, declaration)
+        ]);
+        variableDeclaration.loc = node.loc, path2.insertBefore(variableDeclaration), node.declaration = identifier;
+        let insertedVarPath = path2.getPrevSibling(), initPath = null;
+        if (insertedVarPath?.isVariableDeclaration()) {
+          let declarationPath = insertedVarPath.get("declarations")[0];
+          declarationPath?.isVariableDeclarator() && (initPath = declarationPath.get("init"));
+        }
+        addComponent(identifierName, identifier, initPath);
+        return;
+      }
+      if (t7.isIdentifier(declaration)) {
+        let binding = path2.scope.getBinding(declaration.name);
+        if (!binding)
+          return;
+        let bindingIdentifier = binding.identifier;
+        if (!t7.isIdentifier(bindingIdentifier))
+          return;
+        if (binding.path.isVariableDeclarator())
+          addComponent(
+            createComponentNameFromFileName(fileName),
+            bindingIdentifier,
+            binding.path.get("init")
+          );
+        else if (binding.path.isFunctionDeclaration() || binding.path.isClassDeclaration()) {
+          let bindingNodeId = binding.path.node.id;
+          t7.isIdentifier(bindingNodeId) && addComponent(bindingNodeId.name, bindingIdentifier, binding.path);
+        }
+        return;
+      }
+      if (t7.isFunctionDeclaration(declaration) && declaration.id) {
+        addComponent(
+          declaration.id.name,
+          declaration.id,
+          path2.get("declaration")
+        );
+        return;
+      }
+      t7.isClassDeclaration(declaration) && declaration.id && addComponent(
+        declaration.id.name,
+        declaration.id,
+        path2.get("declaration")
+      );
+    }
+  }), components;
+}, componentTransform = async ({
+  code,
+  fileName,
+  getComponentArgTypes
+}) => {
+  let ast = babelParse4(code), file = new BabelFileClass2({ filename: fileName, highlightCode: !1 }, { code, ast }), components = collectComponentExports(ast.program, fileName);
+  if (!components.length)
+    return { code, map: null };
+  let vitestTestId = file.path.scope.generateUidIdentifier("test"), vitestExpectId = file.path.scope.generateUidIdentifier("expect"), testStoryId = file.path.scope.generateUidIdentifier("testStory"), convertToFilePathId = t7.identifier("convertToFilePath"), fnId = file.path.scope.generateUidIdentifier("fn");
+  dedupeImports(ast.program, VITEST_IMPORT_SOURCE, [
+    t7.importSpecifier(vitestTestId, t7.identifier("test")),
+    t7.importSpecifier(vitestExpectId, t7.identifier("expect"))
+  ]), dedupeImports(ast.program, TEST_UTILS_IMPORT_SOURCE, [
+    t7.importSpecifier(testStoryId, t7.identifier("testStory")),
+    t7.importSpecifier(convertToFilePathId, t7.identifier("convertToFilePath"))
+  ]);
+  let testStatements = [], hasFunctionPlaceholder = (value) => JSON.stringify(value).includes(STORYBOOK_FN_PLACEHOLDER), valueToNodeRecursive = (value, replaceFnCalls) => {
+    if (!replaceFnCalls)
+      return t7.valueToNode(value);
+    if (value === STORYBOOK_FN_PLACEHOLDER)
+      return t7.callExpression(fnId, []);
+    if (typeof value == "object" && value !== null) {
+      if (Array.isArray(value))
+        return t7.arrayExpression(value.map((val) => valueToNodeRecursive(val, replaceFnCalls)));
+      let properties = Object.entries(value).map(([key, val]) => {
+        let keyNode = t7.isValidIdentifier(key) ? t7.identifier(key) : t7.stringLiteral(key);
+        return t7.objectProperty(keyNode, valueToNodeRecursive(val, replaceFnCalls));
+      });
+      return t7.objectExpression(properties);
+    }
+    return t7.valueToNode(value);
+  }, buildArgsExpression = (args, useFnImport = !1) => {
+    if (!args || Object.keys(args).length === 0)
+      return t7.objectExpression([]);
+    let properties = Object.entries(args).map(([key, value]) => {
+      let keyNode = t7.isValidIdentifier(key) ? t7.identifier(key) : t7.stringLiteral(key);
+      return t7.objectProperty(keyNode, valueToNodeRecursive(value, useFnImport));
+    });
+    return t7.objectExpression(properties);
+  }, hasAnyFunctionPlaceholders = !1;
+  for (let component of components) {
+    let argTypes = getComponentArgTypes ? await getComponentArgTypes({ componentName: component.exportedName, fileName }) : void 0, generatedArgs = argTypes ? generateDummyArgsFromArgTypes(argTypes, { skipUrlGeneration: !0 }).required : void 0;
+    !hasAnyFunctionPlaceholders && generatedArgs && hasFunctionPlaceholder(generatedArgs) && (hasAnyFunctionPlaceholders = !0);
+    let meta = t7.objectExpression([
+      t7.objectProperty(
+        t7.identifier("title"),
+        t7.stringLiteral(`generated/tests/${component.exportedName}`)
+      ),
+      t7.objectProperty(t7.identifier("component"), component.localIdentifier)
+    ]), testStoryArgs = t7.objectExpression([
+      t7.objectProperty(t7.identifier("exportName"), t7.stringLiteral(component.exportedName)),
+      // This is where the story annotation for a particular component is defined, inline
+      t7.objectProperty(
+        t7.identifier("story"),
+        t7.objectExpression([
+          t7.objectProperty(
+            t7.identifier("args"),
+            buildArgsExpression(generatedArgs, hasAnyFunctionPlaceholders)
+          )
+        ])
+      ),
+      t7.objectProperty(t7.identifier("meta"), meta),
+      t7.objectProperty(t7.identifier("skipTags"), t7.arrayExpression([])),
+      t7.objectProperty(
+        t7.identifier("storyId"),
+        t7.stringLiteral(`generated-${component.exportedName}`)
+      ),
+      t7.objectProperty(t7.identifier("componentPath"), t7.stringLiteral(fileName)),
+      t7.objectProperty(
+        t7.identifier("componentName"),
+        t7.stringLiteral(component.localIdentifier.name)
+      )
+    ]), testCall = t7.expressionStatement(
+      t7.callExpression(vitestTestId, [
+        t7.stringLiteral(component.exportedName),
+        t7.callExpression(testStoryId, [testStoryArgs])
+      ])
+    );
+    testStatements.push(testCall);
+  }
+  hasAnyFunctionPlaceholders && dedupeImports(ast.program, STORYBOOK_TEST_IMPORT_SOURCE, [
+    t7.importSpecifier(fnId, t7.identifier("fn"))
+  ]);
+  let { declaration: guardDeclaration, identifier: guardIdentifier } = createTestGuardDeclaration(
+    file.path.scope,
+    vitestExpectId,
+    convertToFilePathId
+  );
+  return ast.program.body.push(guardDeclaration), ast.program.body.push(t7.ifStatement(guardIdentifier, t7.blockStatement(testStatements))), generate5(ast, { sourceMaps: !0, sourceFileName: fileName }, code);
+};
+
 export {
+  Tag,
   isValidPreviewPath,
   isModuleMock,
   NoMetaError,
@@ -1559,5 +1946,8 @@ export {
   extractSource,
   extractDescription,
   vitestTransform,
-  babelParse4 as babelParse
+  STORYBOOK_FN_PLACEHOLDER,
+  generateDummyArgsFromArgTypes,
+  componentTransform,
+  babelParse5 as babelParse
 };