create-storybook 10.2.4 → 10.2.6

package/dist/_node-chunks/{chunk-6IPEYKLS.js → chunk-5BPXECTR.js}

@@ -1,21 +1,27 @@
-import CJS_COMPAT_NODE_URL_gzb56xik2ck from 'node:url';
-import CJS_COMPAT_NODE_PATH_gzb56xik2ck from 'node:path';
-import CJS_COMPAT_NODE_MODULE_gzb56xik2ck from "node:module";
+import CJS_COMPAT_NODE_URL_n3uavwb99b from 'node:url';
+import CJS_COMPAT_NODE_PATH_n3uavwb99b from 'node:path';
+import CJS_COMPAT_NODE_MODULE_n3uavwb99b from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_gzb56xik2ck.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_gzb56xik2ck.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_gzb56xik2ck.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_n3uavwb99b.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_n3uavwb99b.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_n3uavwb99b.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
   require_dist
-} from "./chunk-SELEDHTP.js";
+} from "./chunk-6GIN6MWS.js";
+import {
+  dirname,
+  normalize,
+  relative,
+  resolve
+} from "./chunk-OQWKAX3X.js";
 import {
   __commonJS,
   __toESM
-} from "./chunk-FRKTKJP6.js";
+} from "./chunk-THR72EAG.js";
 
 // ../../../node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS({
@@ -563,7 +569,7 @@ import { logger as logger4, prompt as prompt2 } from "storybook/internal/node-lo
 
 // src/services/ProjectTypeService.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { resolve as resolve2 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 import { ProjectType as ProjectType2 } from "storybook/internal/cli";
 import { HandledError, getProjectRoot } from "storybook/internal/common";
 import { logger as logger3 } from "storybook/internal/node-logger";
@@ -575,18 +581,18 @@ import { join as join2 } from "node:path";
 import { existsSync, statSync } from "node:fs";
 
 // ../../../node_modules/empathic/walk.mjs
-import { dirname } from "node:path";
+import { dirname as dirname2 } from "node:path";
 
 // ../../../node_modules/empathic/resolve.mjs
-import { isAbsolute, join, resolve } from "node:path";
+import { isAbsolute, join, resolve as resolve2 } from "node:path";
 function absolute(input, root) {
-  return isAbsolute(input) ? input : resolve(root || ".", input);
+  return isAbsolute(input) ? input : resolve2(root || ".", input);
 }
 
 // ../../../node_modules/empathic/walk.mjs
 function up(base, options) {
   let { last, cwd } = options || {}, tmp = absolute(base, cwd), root = absolute(last || "/", cwd), prev, arr = [];
-  for (; prev !== root && (arr.push(tmp), tmp = dirname(prev = tmp), tmp !== prev); )
+  for (; prev !== root && (arr.push(tmp), tmp = dirname2(prev = tmp), tmp !== prev); )
     ;
   return arr;
 }
@@ -695,7 +701,7 @@ var ProjectTypeService = class {
       }
     ];
   }
-  isStorybookInstantiated(configDir = resolve2(process.cwd(), ".storybook")) {
+  isStorybookInstantiated(configDir = resolve3(process.cwd(), ".storybook")) {
     return existsSync2(configDir);
   }
   async validateProvidedType(projectTypeProvided) {
@@ -743,8 +749,8 @@ var ProjectTypeService = class {
       getModulePackageJSONVersion("@babel/plugin-transform-typescript"),
       getModulePackageJSONVersion("@typescript-eslint/parser"),
       getModulePackageJSONVersion("eslint-plugin-storybook")
-    ]), satisfies = (version, range) => version ? semver.satisfies(version, range, { includePrerelease: !0 }) : !1;
-    return isTypescriptDirectDependency && typescriptVersion ? satisfies(typescriptVersion, ">=4.9.0") && (!prettierVersion || semver.gte(prettierVersion, "2.8.0")) && (!babelPluginTransformTypescriptVersion || satisfies(babelPluginTransformTypescriptVersion, ">=7.20.0")) && (!typescriptEslintParserVersion || satisfies(typescriptEslintParserVersion, ">=5.44.0")) && (!eslintPluginStorybookVersion || satisfies(eslintPluginStorybookVersion, ">=0.6.8")) ? language = SupportedLanguage.TYPESCRIPT : logger3.warn(
+    ]), satisfies2 = (version, range) => version ? semver.satisfies(version, range, { includePrerelease: !0 }) : !1;
+    return isTypescriptDirectDependency && typescriptVersion ? satisfies2(typescriptVersion, ">=4.9.0") && (!prettierVersion || semver.gte(prettierVersion, "2.8.0")) && (!babelPluginTransformTypescriptVersion || satisfies2(babelPluginTransformTypescriptVersion, ">=7.20.0")) && (!typescriptEslintParserVersion || satisfies2(typescriptEslintParserVersion, ">=5.44.0")) && (!eslintPluginStorybookVersion || satisfies2(eslintPluginStorybookVersion, ">=0.6.8")) ? language = SupportedLanguage.TYPESCRIPT : logger3.warn(
       "Detected TypeScript < 4.9 or incompatible tooling, populating with JavaScript examples"
     ) : existsSync2("tsconfig.json") && (language = SupportedLanguage.TYPESCRIPT), language;
   }
@@ -1029,7 +1035,7 @@ var UserPreferencesCommand = class {
 
 // src/generators/baseGenerator.ts
 import { mkdir } from "node:fs/promises";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { dirname as dirname3, join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   configureEslintPlugin,
@@ -1062,7 +1068,7 @@ var import_ts_dedent7 = __toESM(require_dist(), 1);
 // src/generators/configure.ts
 var import_ts_dedent6 = __toESM(require_dist(), 1);
 import { stat, writeFile } from "node:fs/promises";
-import { resolve as resolve3 } from "node:path";
+import { resolve as resolve4 } from "node:path";
 import { logger as logger8 } from "storybook/internal/node-logger";
 import { Feature as Feature4, SupportedLanguage as SupportedLanguage2 } from "storybook/internal/types";
 var pathExists = async (path) => stat(path).then(() => !0).catch(() => !1);
@@ -1076,7 +1082,7 @@ async function configureMain({
   features,
   ...custom
 }) {
-  let srcPath = resolve3(storybookConfigFolder, "../src"), prefix2 = await pathExists(srcPath) ? "../src" : "../stories", stories = features.has(Feature4.DOCS) ? [`${prefix2}/**/*.mdx`] : [];
+  let srcPath = resolve4(storybookConfigFolder, "../src"), prefix2 = await pathExists(srcPath) ? "../src" : "../stories", stories = features.has(Feature4.DOCS) ? [`${prefix2}/**/*.mdx`] : [];
   stories.push(`${prefix2}/**/*.stories.@(${extensions.join("|")})`);
   let config = {
     stories,
@@ -1284,7 +1290,7 @@ async function baseGenerator(packageManager, npmOptions, { language, builder, fr
       language,
       destination: componentsDestinationPath,
       commonAssetsDir: join3(
-        dirname2(fileURLToPath(import.meta.resolve("create-storybook/package.json"))),
+        dirname3(fileURLToPath(import.meta.resolve("create-storybook/package.json"))),
         "rendererAssets",
         "common"
       ),
@@ -1388,14 +1394,554 @@ var GeneratorExecutionCommand = class {
 }) => new GeneratorExecutionCommand(dependencyCollector, packageManager).execute(options);
 
 // src/commands/AddonConfigurationCommand.ts
-var import_ts_dedent8 = __toESM(require_dist(), 1);
-import { AddonVitestService as AddonVitestService2 } from "storybook/internal/cli";
-import { CLI_COLORS as CLI_COLORS2, logger as logger9, prompt as prompt6 } from "storybook/internal/node-logger";
+var import_ts_dedent9 = __toESM(require_dist(), 1);
+import { AddonVitestService as AddonVitestService3 } from "storybook/internal/cli";
+import { CLI_COLORS as CLI_COLORS3, logger as logger9, prompt as prompt6 } from "storybook/internal/node-logger";
 import { ErrorCollector } from "storybook/internal/telemetry";
+
+// ../../addons/a11y/src/postinstall.ts
+import { JsPackageManagerFactory as JsPackageManagerFactory2, versions as versions2 } from "storybook/internal/common";
+async function postinstall(options) {
+  let args = [
+    options.skipInstall ? `storybook@${versions2.storybook}` : "storybook",
+    "automigrate",
+    "addon-a11y-addon-test"
+  ];
+  args.push("--loglevel", "silent"), args.push("--skip-doctor"), options.yes && args.push("--yes"), options.packageManager && args.push("--package-manager", options.packageManager), options.configDir && args.push("--config-dir", options.configDir), await JsPackageManagerFactory2.getPackageManager({
+    force: options.packageManager,
+    configDir: options.configDir
+  }).runPackageCommand({ args, useRemotePkg: !!options.skipInstall });
+}
+
+// ../../addons/vitest/src/postinstall.ts
+import { existsSync as existsSync3 } from "node:fs";
+import * as fs from "node:fs/promises";
+import { writeFile as writeFile2 } from "node:fs/promises";
+import { babelParse, generate, traverse } from "storybook/internal/babel";
+import { AddonVitestService as AddonVitestService2 } from "storybook/internal/cli";
+import {
+  JsPackageManagerFactory as JsPackageManagerFactory3,
+  formatFileContent,
+  getProjectRoot as getProjectRoot3,
+  getStorybookInfo,
+  versions as versions3
+} from "storybook/internal/common";
+import { CLI_COLORS as CLI_COLORS2 } from "storybook/internal/node-logger";
+import {
+  AddonVitestPostinstallConfigUpdateError,
+  AddonVitestPostinstallError,
+  AddonVitestPostinstallFailedAddonA11yError,
+  AddonVitestPostinstallPrerequisiteCheckError,
+  AddonVitestPostinstallWorkspaceUpdateError
+} from "storybook/internal/server-errors";
+import { SupportedFramework as SupportedFramework3 } from "storybook/internal/types";
+var import_ts_dedent8 = __toESM(require_dist(), 1);
+import { coerce, satisfies } from "semver";
+
+// ../../core/src/component-testing/constants.ts
+var ADDON_ID = "storybook/interactions", PANEL_ID = `${ADDON_ID}/panel`;
+var DOCUMENTATION_LINK = "writing-tests/integrations/vitest-addon", DOCUMENTATION_DISCREPANCY_LINK = `${DOCUMENTATION_LINK}#what-happens-when-there-are-different-test-results-in-multiple-environments`;
+
+// ../../addons/a11y/src/constants.ts
+var ADDON_ID2 = "storybook/a11y", PANEL_ID2 = `${ADDON_ID2}/panel`;
+var UI_STATE_ID = `${ADDON_ID2}/ui`, RESULT = `${ADDON_ID2}/result`, REQUEST = `${ADDON_ID2}/request`, RUNNING = `${ADDON_ID2}/running`, ERROR = `${ADDON_ID2}/error`, MANUAL = `${ADDON_ID2}/manual`, SELECT = `${ADDON_ID2}/select`, DOCUMENTATION_LINK2 = "writing-tests/accessibility-testing", DOCUMENTATION_DISCREPANCY_LINK2 = `${DOCUMENTATION_LINK2}#why-are-my-tests-failing-in-different-environments`;
+
+// ../../addons/vitest/src/constants.ts
+var ADDON_ID3 = "storybook/test", TEST_PROVIDER_ID = `${ADDON_ID3}/test-provider`, STORYBOOK_ADDON_TEST_CHANNEL = `${ADDON_ID3}/channel`;
+var DOCUMENTATION_LINK3 = "writing-tests/integrations/vitest-addon", DOCUMENTATION_FATAL_ERROR_LINK = `${DOCUMENTATION_LINK3}#what-happens-if-vitest-itself-has-an-error`;
+var storeOptions = {
+  id: ADDON_ID3,
+  initialState: {
+    config: {
+      coverage: !1,
+      a11y: !1
+    },
+    watching: !1,
+    cancelling: !1,
+    fatalError: void 0,
+    indexUrl: void 0,
+    previewAnnotations: [],
+    currentRun: {
+      triggeredBy: void 0,
+      config: {
+        coverage: !1,
+        a11y: !1
+      },
+      componentTestCount: {
+        success: 0,
+        error: 0
+      },
+      a11yCount: {
+        success: 0,
+        warning: 0,
+        error: 0
+      },
+      storyIds: void 0,
+      totalTestCount: void 0,
+      startedAt: void 0,
+      finishedAt: void 0,
+      unhandledErrors: [],
+      coverageSummary: void 0
+    }
+  }
+};
+var STORE_CHANNEL_EVENT_NAME = `UNIVERSAL_STORE:${storeOptions.id}`;
+
+// ../../addons/vitest/src/updateVitestFile.ts
+async function getTemplatePath(name) {
+  switch (name) {
+    case "vitest.config.template":
+      return import("./vitest.config-7QH3VAVK.js");
+    case "vitest.config.4.template":
+      return import("./vitest.config.4-IRNJJKM3.js");
+    case "vitest.config.3.2.template":
+      return import("./vitest.config.3.2-HJ3TVZJ4.js");
+    case "vitest.workspace.template":
+      return import("./vitest.workspace-YTF65SM6.js");
+    default:
+      throw new Error(`Unknown template: ${name}`);
+  }
+}
+var loadTemplate = async (name, replacements) => {
+  let template = (await getTemplatePath(name)).default;
+  return Object.entries(replacements).forEach(
+    ([key, value]) => template = template.replace(key, normalize(value))
+  ), template;
+}, mergeProperties = (source, target) => {
+  for (let sourceProp of source)
+    if (sourceProp.type === "ObjectProperty") {
+      let targetProp = target.find(
+        (p) => sourceProp.key.type === "Identifier" && p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === sourceProp.key.name
+      );
+      targetProp && targetProp.type === "ObjectProperty" ? sourceProp.value.type === "ObjectExpression" && targetProp.value.type === "ObjectExpression" ? mergeProperties(sourceProp.value.properties, targetProp.value.properties) : sourceProp.value.type === "ArrayExpression" && targetProp.value.type === "ArrayExpression" ? targetProp.value.elements.push(...sourceProp.value.elements) : targetProp.value = sourceProp.value : target.push(sourceProp);
+    }
+}, getTargetConfigObject = (target, exportDefault) => {
+  let decl = exportDefault.declaration;
+  if (decl.type === "ObjectExpression")
+    return decl;
+  if (decl.type === "CallExpression" && decl.callee.type === "Identifier" && decl.callee.name === "defineConfig" && decl.arguments[0]?.type === "ObjectExpression")
+    return decl.arguments[0];
+  if (decl.type === "Identifier") {
+    let varName = decl.name, varDecl = target.program.body.find(
+      (n) => n.type === "VariableDeclaration" && n.declarations.some((d) => d.id.type === "Identifier" && d.id.name === varName)
+    );
+    if (!varDecl)
+      return null;
+    let declarator = varDecl.declarations.find(
+      (d) => d.id.type === "Identifier" && d.id.name === varName
+    );
+    if (!declarator?.init)
+      return null;
+    let init = declarator.init;
+    return init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "defineConfig" && init.arguments[0]?.type === "ObjectExpression" ? init.arguments[0] : init.type === "ObjectExpression" ? init : null;
+  }
+  return null;
+}, updateConfigFile = (source, target) => {
+  let updated = !1, sourceExportDefault = source.program.body.find(
+    (n) => n.type === "ExportDefaultDeclaration"
+  );
+  if (!sourceExportDefault || sourceExportDefault.declaration.type !== "CallExpression")
+    return !1;
+  let targetExportDefault = target.program.body.find(
+    (n) => n.type === "ExportDefaultDeclaration"
+  );
+  if (!targetExportDefault)
+    return !1;
+  let rejectFunctionNotation = (decl) => decl.type === "CallExpression" && decl.callee.type === "Identifier" && decl.callee.name === "defineConfig" && decl.arguments.length > 0 && decl.arguments[0].type === "ArrowFunctionExpression";
+  if (targetExportDefault.declaration.type === "CallExpression" && rejectFunctionNotation(targetExportDefault.declaration))
+    return !1;
+  if (targetExportDefault.declaration.type === "Identifier") {
+    let varName = targetExportDefault.declaration.name, declarator = target.program.body.find(
+      (n) => n.type === "VariableDeclaration" && n.declarations.some((d) => d.id.type === "Identifier" && d.id.name === varName)
+    )?.declarations.find(
+      (d) => d.id.type === "Identifier" && d.id.name === varName
+    );
+    if (declarator?.init?.type === "CallExpression" && rejectFunctionNotation(declarator.init))
+      return !1;
+  }
+  let canHandleConfig = !1;
+  if ((getTargetConfigObject(target, targetExportDefault) !== null || targetExportDefault.declaration.type === "CallExpression" && targetExportDefault.declaration.callee.type === "Identifier" && targetExportDefault.declaration.callee.name === "mergeConfig" && targetExportDefault.declaration.arguments.length >= 2) && (canHandleConfig = !0), !canHandleConfig)
+    return !1;
+  for (let sourceNode of source.program.body)
+    if (sourceNode.type === "ImportDeclaration") {
+      if (!target.program.body.some(
+        (targetNode) => targetNode.type === sourceNode.type && targetNode.specifiers.some((s) => s.local.name === sourceNode.specifiers[0].local.name)
+      )) {
+        let lastImport = target.program.body.findLastIndex((n) => n.type === "ImportDeclaration");
+        target.program.body.splice(lastImport + 1, 0, sourceNode);
+      }
+    } else if (sourceNode.type === "VariableDeclaration") {
+      if (!target.program.body.some(
+        (targetNode) => targetNode.type === sourceNode.type && targetNode.declarations.some(
+          (d) => "name" in d.id && "name" in sourceNode.declarations[0].id && d.id.name === sourceNode.declarations[0].id.name
+        )
+      )) {
+        let lastImport = target.program.body.findLastIndex((n) => n.type === "ImportDeclaration");
+        target.program.body.splice(lastImport + 1, 0, sourceNode);
+      }
+    } else if (sourceNode.type === "ExportDefaultDeclaration") {
+      let exportDefault = target.program.body.find((n) => n.type === "ExportDefaultDeclaration");
+      if (exportDefault && sourceNode.declaration.type === "CallExpression" && sourceNode.declaration.arguments.length > 0 && sourceNode.declaration.arguments[0].type === "ObjectExpression") {
+        let { properties } = sourceNode.declaration.arguments[0], targetConfigObject = getTargetConfigObject(target, exportDefault);
+        if (targetConfigObject !== null)
+          mergeProperties(properties, targetConfigObject.properties), updated = !0;
+        else if (exportDefault.declaration.type === "CallExpression" && exportDefault.declaration.callee.type === "Identifier" && exportDefault.declaration.callee.name === "mergeConfig" && exportDefault.declaration.arguments.length >= 2) {
+          let configObjectNodes = [];
+          for (let arg of exportDefault.declaration.arguments)
+            arg?.type === "CallExpression" && arg.callee.type === "Identifier" && arg.callee.name === "defineConfig" && arg.arguments[0]?.type === "ObjectExpression" ? configObjectNodes.push(arg.arguments[0]) : arg?.type === "ObjectExpression" && configObjectNodes.push(arg);
+          let targetConfigObject2 = configObjectNodes.find(
+            (obj) => obj.properties.some(
+              (p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === "test"
+            )
+          ) || configObjectNodes[0];
+          if (!targetConfigObject2)
+            return !1;
+          let existingTestProp = targetConfigObject2.properties.find(
+            (p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === "test"
+          );
+          if (existingTestProp && existingTestProp.value.type === "ObjectExpression") {
+            let templateTestProp = properties.find(
+              (p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === "test"
+            ), hasProjectsProp = (p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === "projects" && p.value.type === "ArrayExpression", existingProjectsProp = existingTestProp.value.properties.find(hasProjectsProp);
+            if (existingProjectsProp) {
+              if (templateTestProp && templateTestProp.value.type === "ObjectExpression") {
+                let templateProjectsProp = templateTestProp.value.properties.find(hasProjectsProp);
+                if (templateProjectsProp && templateProjectsProp.value.type === "ArrayExpression") {
+                  let templateElements = templateProjectsProp.value.elements;
+                  existingProjectsProp.value.elements.push(
+                    ...templateElements
+                  );
+                }
+                for (let templateProp of templateTestProp.value.properties)
+                  templateProp.type === "ObjectProperty" && templateProp.key.type === "Identifier" && templateProp.key.name !== "projects" && !existingTestProp.value.properties.find(
+                    (p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === templateProp.key.name
+                  ) && templateProp.type === "ObjectProperty" && existingTestProp.value.properties.push(templateProp);
+              }
+              let otherTemplateProps = properties.filter(
+                (p) => !(p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === "test")
+              );
+              otherTemplateProps.length > 0 && mergeProperties(otherTemplateProps, targetConfigObject2.properties);
+            } else if (templateTestProp && templateTestProp.value.type === "ObjectExpression") {
+              let workspaceOrProjectsProp = templateTestProp.value.properties.find(
+                (p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && (p.key.name === "workspace" || p.key.name === "projects")
+              );
+              if (workspaceOrProjectsProp && workspaceOrProjectsProp.value.type === "ArrayExpression") {
+                let coverageProp = existingTestProp.value.properties.find(
+                  (p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === "coverage"
+                ), testConfigForProject = {
+                  type: "ObjectExpression",
+                  properties: existingTestProp.value.properties.filter(
+                    (p) => p !== coverageProp
+                  )
+                }, existingTestProject = {
+                  type: "ObjectExpression",
+                  properties: [
+                    {
+                      type: "ObjectProperty",
+                      key: { type: "Identifier", name: "extends" },
+                      value: { type: "BooleanLiteral", value: !0 },
+                      computed: !1,
+                      shorthand: !1
+                    },
+                    {
+                      type: "ObjectProperty",
+                      key: { type: "Identifier", name: "test" },
+                      value: testConfigForProject,
+                      computed: !1,
+                      shorthand: !1
+                    }
+                  ]
+                };
+                workspaceOrProjectsProp.value.elements.unshift(existingTestProject), targetConfigObject2.properties = targetConfigObject2.properties.filter(
+                  (p) => p !== existingTestProp
+                ), coverageProp && templateTestProp.value.type === "ObjectExpression" && templateTestProp.value.properties.unshift(coverageProp), mergeProperties(properties, targetConfigObject2.properties);
+              } else
+                mergeProperties(properties, targetConfigObject2.properties);
+            } else
+              mergeProperties(properties, targetConfigObject2.properties);
+          } else
+            mergeProperties(properties, targetConfigObject2.properties);
+          updated = !0;
+        }
+      }
+    }
+  return updated;
+}, updateWorkspaceFile = (source, target) => {
+  let updated = !1;
+  for (let sourceNode of source.program.body)
+    if (sourceNode.type === "ImportDeclaration") {
+      if (!target.program.body.some(
+        (targetNode) => targetNode.type === sourceNode.type && targetNode.source.value === sourceNode.source.value && targetNode.specifiers.some((s) => s.local.name === sourceNode.specifiers[0].local.name)
+      )) {
+        let lastImport = target.program.body.findLastIndex((n) => n.type === "ImportDeclaration");
+        target.program.body.splice(lastImport + 1, 0, sourceNode);
+      }
+    } else if (sourceNode.type === "VariableDeclaration") {
+      if (!target.program.body.some(
+        (targetNode) => targetNode.type === sourceNode.type && targetNode.declarations.some(
+          (d) => "name" in d.id && "name" in sourceNode.declarations[0].id && d.id.name === sourceNode.declarations[0].id.name
+        )
+      )) {
+        let lastImport = target.program.body.findLastIndex((n) => n.type === "ImportDeclaration");
+        target.program.body.splice(lastImport + 1, 0, sourceNode);
+      }
+    } else if (sourceNode.type === "ExportDefaultDeclaration") {
+      let exportDefault = target.program.body.find((n) => n.type === "ExportDefaultDeclaration");
+      if (exportDefault && sourceNode.declaration.type === "CallExpression" && sourceNode.declaration.arguments.length > 0 && sourceNode.declaration.arguments[0].type === "ArrayExpression" && sourceNode.declaration.arguments[0].elements.length > 0) {
+        let { elements } = sourceNode.declaration.arguments[0];
+        exportDefault.declaration.type === "ArrayExpression" ? (exportDefault.declaration.elements.push(...elements), updated = !0) : exportDefault.declaration.type === "CallExpression" && exportDefault.declaration.callee.type === "Identifier" && exportDefault.declaration.callee.name === "defineWorkspace" && exportDefault.declaration.arguments[0]?.type === "ArrayExpression" && (exportDefault.declaration.arguments[0].elements.push(...elements), updated = !0);
+      }
+    }
+  return updated;
+};
+
+// ../../addons/vitest/src/postinstall.ts
+var ADDON_NAME = "@storybook/addon-vitest", EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".cts", ".mts", ".cjs", ".mjs"], STORYBOOK_TEST_PLUGIN_SOURCE = `${ADDON_NAME}/vitest-plugin`, addonA11yName = "@storybook/addon-a11y";
+async function postInstall(options) {
+  let errors = [], { logger: logger17, prompt: prompt10 } = options, packageManager = JsPackageManagerFactory3.getPackageManager({
+    force: options.packageManager
+  }), findFile = (basename, extensions = EXTENSIONS) => any(
+    extensions.map((ext) => basename + ext),
+    { last: getProjectRoot3(), cwd: options.configDir }
+  ), allDeps = packageManager.getAllDependencies(), vitestVersionSpecifier = await packageManager.getInstalledVersion("vitest");
+  !vitestVersionSpecifier && allDeps.vitest && (vitestVersionSpecifier = allDeps.vitest), vitestVersionSpecifier = coerce(vitestVersionSpecifier)?.version ?? null, logger17.debug(`Vitest version specifier: ${vitestVersionSpecifier}`);
+  let isVitest3_2To4 = vitestVersionSpecifier ? satisfies(vitestVersionSpecifier, ">=3.2.0 <4.0.0") : !1, isVitest4OrNewer = vitestVersionSpecifier ? satisfies(vitestVersionSpecifier, ">=4.0.0") : !0, info = await getStorybookInfo(options.configDir), addonVitestService = new AddonVitestService2(packageManager), compatibilityResult = await addonVitestService.validateCompatibility({
+    framework: info.framework,
+    builder: info.builder
+  }), result = null;
+  if (!compatibilityResult.compatible && compatibilityResult.reasons) {
+    let reasons = compatibilityResult.reasons.map((r) => `\u2022 ${CLI_COLORS2.error(r)}`);
+    reasons.unshift(import_ts_dedent8.dedent`
+      Automated setup failed
+      The following packages have incompatibilities that prevent automated setup:
+    `), reasons.push(
+      import_ts_dedent8.dedent`
+        You can fix these issues and rerun the command to reinstall. If you wish to roll back the installation, remove ${ADDON_NAME} from the "addons" array
+        in your main Storybook config file and remove the dependency from your package.json file.
+
+        Please check the documentation for more information about its requirements and installation:
+        https://storybook.js.org/docs/next/${DOCUMENTATION_LINK3}
+      `
+    ), result = reasons.map((r) => r.trim()).join(`
+
+`);
+  }
+  if (result)
+    throw logger17.error(result), new AddonVitestPostinstallPrerequisiteCheckError({
+      reasons: compatibilityResult.reasons
+    });
+  if (!options.skipDependencyManagement) {
+    let versionedDependencies = await addonVitestService.collectDependencies();
+    info.framework === SupportedFramework3.NEXTJS && packageManager.getAllDependencies()["@storybook/nextjs-vite"];
+    let v8Version = await packageManager.getInstalledVersion("@vitest/coverage-v8"), istanbulVersion = await packageManager.getInstalledVersion("@vitest/coverage-istanbul");
+    !v8Version && !istanbulVersion && logger17.step(
+      import_ts_dedent8.dedent`
+          You don't seem to have a coverage reporter installed. Vitest needs either V8 or Istanbul to generate coverage reports.
+
+          Adding "@vitest/coverage-v8" to enable coverage reporting.
+          Read more about Vitest coverage providers at https://vitest.dev/guide/coverage.html#coverage-providers
+        `
+    ), versionedDependencies.length > 0 && (logger17.step("Adding dependencies to your package.json"), logger17.log("  " + versionedDependencies.join(", ")), await packageManager.addDependencies(
+      { type: "devDependencies", skipInstall: !0 },
+      versionedDependencies
+    )), options.skipInstall || await packageManager.installDependencies();
+  }
+  options.skipDependencyManagement || (options.skipInstall ? logger17.warn(import_ts_dedent8.dedent`
+        Playwright browser binaries installation skipped. Please run the following command manually later:
+        ${CLI_COLORS2.cta("npx playwright install chromium --with-deps")}
+      `) : await addonVitestService.installPlaywright({
+    yes: options.yes,
+    useRemotePkg: !!options.skipInstall
+  }));
+  let fileExtension = allDeps.typescript || findFile("tsconfig", [...EXTENSIONS, ".json"]) ? "ts" : "js", vitestSetupFile = resolve(options.configDir, `vitest.setup.${fileExtension}`), existingSetupFile = EXTENSIONS.map((ext) => resolve(options.configDir, `vitest.setup${ext}`)).find(existsSync3) || null;
+  if (existingSetupFile)
+    logger17.step("Found existing Vitest setup file, reusing:"), logger17.log(`${existingSetupFile}
+`);
+  else {
+    logger17.step("Creating a Vitest setup file for Storybook:"), logger17.log(`${vitestSetupFile}
+`);
+    let previewExists = EXTENSIONS.map((ext) => resolve(options.configDir, `preview${ext}`)).some(
+      existsSync3
+    ), imports = [`import { setProjectAnnotations } from '${info.frameworkPackage}';`], projectAnnotations = [];
+    previewExists && (imports.push("import * as projectAnnotations from './preview';"), projectAnnotations.push("projectAnnotations")), await writeFile2(
+      vitestSetupFile,
+      import_ts_dedent8.dedent`
+      ${imports.join(`
+`)}
+
+      // This is an important step to apply the right configuration when testing your stories.
+      // More info at: https://storybook.js.org/docs/api/portable-stories/portable-stories-vitest#setprojectannotations
+      setProjectAnnotations([${projectAnnotations.join(", ")}]);
+    `
+    );
+  }
+  let vitestWorkspaceFile = findFile("vitest.workspace", [".ts", ".js", ".json"]), viteConfigFile = findFile("vite.config"), vitestConfigFile = findFile("vitest.config"), vitestShimFile = findFile("vitest.shims.d"), rootConfig = vitestConfigFile || viteConfigFile;
+  fileExtension === "ts" && !vitestShimFile && await writeFile2(
+    "vitest.shims.d.ts",
+    isVitest4OrNewer ? '/// <reference types="@vitest/browser-playwright" />' : '/// <reference types="@vitest/browser/providers/playwright" />'
+  );
+  let getTemplateName = () => isVitest4OrNewer ? "vitest.config.4.template" : isVitest3_2To4 ? "vitest.config.3.2.template" : "vitest.config.template";
+  if (vitestWorkspaceFile) {
+    let workspaceFileContent = await fs.readFile(vitestWorkspaceFile, "utf8");
+    if (isConfigAlreadySetup(vitestWorkspaceFile, workspaceFileContent)) {
+      logger17.step(
+        CLI_COLORS2.success("Vitest for Storybook is already properly configured. Skipping setup.")
+      );
+      return;
+    }
+    let workspaceTemplate = await loadTemplate("vitest.workspace.template", {
+      EXTENDS_WORKSPACE: viteConfigFile ? relative(dirname(vitestWorkspaceFile), viteConfigFile) : "",
+      CONFIG_DIR: options.configDir,
+      SETUP_FILE: relative(dirname(vitestWorkspaceFile), existingSetupFile ?? vitestSetupFile)
+    }).then((t) => t.replace(`
+  'ROOT_CONFIG',`, "").replace(/\s+extends: '',/, "")), source = babelParse(workspaceTemplate), target = babelParse(workspaceFileContent);
+    if (updateWorkspaceFile(source, target)) {
+      logger17.step("Updating your Vitest workspace file..."), logger17.log(`${vitestWorkspaceFile}`);
+      let formattedContent = await formatFileContent(vitestWorkspaceFile, generate(target).code);
+      await writeFile2(vitestWorkspaceFile, formattedContent);
+    } else
+      logger17.error(
+        import_ts_dedent8.dedent`
+          Could not update existing Vitest workspace file:
+          ${vitestWorkspaceFile}
+
+          I was able to configure most of the addon but could not safely extend
+          your existing workspace file automatically, you must do it yourself.
+
+          Please refer to the documentation to complete the setup manually:
+          https://storybook.js.org/docs/next/${DOCUMENTATION_LINK3}#manual-setup-advanced
+        `
+      ), errors.push(
+        new AddonVitestPostinstallWorkspaceUpdateError({ filePath: vitestWorkspaceFile })
+      );
+  } else if (rootConfig) {
+    let target, updated, configFile = await fs.readFile(rootConfig, "utf8"), configFileHasTypeReference = configFile.match(
+      /\/\/\/\s*<reference\s+types=["']vitest\/config["']\s*\/>/
+    ), templateName = getTemplateName(), alreadyConfigured = isConfigAlreadySetup(rootConfig, configFile);
+    if (templateName && !alreadyConfigured) {
+      let configTemplate = await loadTemplate(templateName, {
+        CONFIG_DIR: options.configDir,
+        SETUP_FILE: relative(dirname(rootConfig), existingSetupFile ?? vitestSetupFile)
+      }), source = babelParse(configTemplate);
+      target = babelParse(configFile), updated = updateConfigFile(source, target);
+    }
+    if (alreadyConfigured)
+      logger17.step(
+        CLI_COLORS2.success("Vitest for Storybook is already properly configured. Skipping setup.")
+      );
+    else if (target && updated) {
+      logger17.step(`Updating your ${vitestConfigFile ? "Vitest" : "Vite"} config file:`), logger17.log(`  ${rootConfig}`);
+      let formattedContent = await formatFileContent(rootConfig, generate(target).code);
+      await writeFile2(
+        rootConfig,
+        !configFileHasTypeReference && !vitestConfigFile ? `/// <reference types="vitest/config" />
+` + formattedContent : formattedContent
+      );
+    } else
+      logger17.error(import_ts_dedent8.dedent`
+        We were unable to update your existing ${vitestConfigFile ? "Vitest" : "Vite"} config file.
+
+        Please refer to the documentation to complete the setup manually:
+        https://storybook.js.org/docs/writing-tests/integrations/vitest-addon#manual-setup-advanced
+      `), errors.push(new AddonVitestPostinstallConfigUpdateError({ filePath: rootConfig }));
+  } else {
+    let parentDir = dirname(options.configDir), newConfigFile = resolve(parentDir, `vitest.config.${fileExtension}`), configTemplate = await loadTemplate(getTemplateName(), {
+      CONFIG_DIR: options.configDir,
+      SETUP_FILE: relative(dirname(newConfigFile), vitestSetupFile)
+    });
+    logger17.step("Creating a Vitest config file:"), logger17.log(`${newConfigFile}`);
+    let formattedContent = await formatFileContent(newConfigFile, configTemplate);
+    await writeFile2(newConfigFile, formattedContent);
+  }
+  if (info.addons.find((addon) => addon.includes(addonA11yName)))
+    try {
+      let command = [
+        options.skipInstall ? `storybook@${versions3.storybook}` : "storybook",
+        "automigrate",
+        "addon-a11y-addon-test",
+        "--loglevel",
+        "silent",
+        "--yes",
+        "--skip-doctor"
+      ];
+      options.packageManager && command.push("--package-manager", options.packageManager), options.skipInstall && command.push("--skip-install"), options.configDir !== ".storybook" && command.push("--config-dir", options.configDir), await prompt10.executeTask(
+        // TODO: Remove stdio: 'ignore' once we have a way to log the output of the command properly
+        () => packageManager.runPackageCommand({
+          args: command,
+          stdio: "ignore",
+          useRemotePkg: !!options.skipInstall
+        }),
+        {
+          intro: "Setting up a11y addon for @storybook/addon-vitest",
+          error: "Failed to setup a11y addon for @storybook/addon-vitest",
+          success: "a11y addon setup successfully"
+        }
+      );
+    } catch (e) {
+      logger17.error(import_ts_dedent8.dedent`
+        Could not automatically set up ${addonA11yName} for @storybook/addon-vitest.
+        Please refer to the documentation to complete the setup manually:
+        https://storybook.js.org/docs/writing-tests/accessibility-testing#integration-with-vitest-addon
+      `), errors.push(new AddonVitestPostinstallFailedAddonA11yError({ error: e }));
+    }
+  let runCommand = rootConfig ? "npx vitest --project=storybook" : "npx vitest";
+  if (errors.length === 0)
+    logger17.step(CLI_COLORS2.success("@storybook/addon-vitest setup completed successfully")), logger17.log(import_ts_dedent8.dedent`
+        @storybook/addon-vitest is now configured and you're ready to run your tests!
+        Here are a couple of tips to get you started:
+
+        • You can run tests with "${CLI_COLORS2.cta(runCommand)}"
+        • Vitest IDE extension shows all stories as tests in your editor!
+
+        Check the documentation for more information about its features and options at:
+        https://storybook.js.org/docs/next/${DOCUMENTATION_LINK3}
+      `);
+  else
+    throw logger17.warn(
+      import_ts_dedent8.dedent`
+        Done, but with errors!
+        @storybook/addon-vitest was installed successfully, but there were some errors during the setup process. Please refer to the documentation to complete the setup manually and check the errors above:
+        https://storybook.js.org/docs/next/${DOCUMENTATION_LINK3}#manual-setup-advanced
+      `
+    ), new AddonVitestPostinstallError({ errors });
+}
+function isStorybookTestPluginSource(value) {
+  return value === STORYBOOK_TEST_PLUGIN_SOURCE;
+}
+function isConfigAlreadySetup(_configPath, configContent) {
+  let ast;
+  try {
+    ast = babelParse(configContent);
+  } catch {
+    return !1;
+  }
+  let pluginIdentifiers = /* @__PURE__ */ new Set();
+  traverse(ast, {
+    ImportDeclaration(path) {
+      let source = path.node.source.value;
+      typeof source == "string" && isStorybookTestPluginSource(source) && path.node.specifiers.forEach((specifier) => {
+        "local" in specifier && specifier.local?.name && pluginIdentifiers.add(specifier.local.name);
+      });
+    }
+  });
+  let pluginReferenced = !1;
+  return traverse(ast, {
+    CallExpression(path) {
+      if (pluginReferenced) {
+        path.stop();
+        return;
+      }
+      let callee = path.node.callee;
+      callee.type === "Identifier" && (pluginIdentifiers.has(callee.name) || callee.name === "storybookTest") && (pluginReferenced = !0, path.stop());
+    }
+  }), pluginReferenced;
+}
+
+// src/commands/AddonConfigurationCommand.ts
 var ADDON_INSTALLATION_INSTRUCTIONS = {
   "@storybook/addon-vitest": "https://storybook.js.org/docs/writing-tests/integrations/vitest-addon#manual-setup-advanced"
 }, AddonConfigurationCommand = class {
-  constructor(packageManager, commandOptions, addonVitestService = new AddonVitestService2(packageManager), telemetryService = new TelemetryService(commandOptions.disableTelemetry)) {
+  constructor(packageManager, commandOptions, addonVitestService = new AddonVitestService3(packageManager), telemetryService = new TelemetryService(commandOptions.disableTelemetry)) {
     this.packageManager = packageManager;
     this.commandOptions = commandOptions;
     this.addonVitestService = addonVitestService;
@@ -1404,22 +1950,22 @@ var ADDON_INSTALLATION_INSTRUCTIONS = {
   /** Execute addon configuration */
   async execute({
     addons,
-    configDir,
-    dependencyInstallationResult
+    configDir
   }) {
-    if (!(dependencyInstallationResult.status === "success" && !this.commandOptions.skipInstall) && this.getAddonsWithInstructions(addons).length > 0)
-      return this.logManualAddonInstructions(addons), { status: "failed" };
     if (!configDir || addons.length === 0)
       return { status: "success" };
     try {
       let { hasFailures, addonResults } = await this.configureAddons(configDir, addons);
       if (addonResults.has("@storybook/addon-vitest")) {
         let { result } = await this.addonVitestService.installPlaywright({
-          yes: this.commandOptions.yes
+          yes: this.commandOptions.yes,
+          useRemotePkg: !!this.commandOptions.skipInstall
         });
         await this.telemetryService.trackPlaywrightPromptDecision(result);
       }
-      return { status: hasFailures ? "failed" : "success" };
+      return hasFailures && this.logManualAddonInstructions(
+        addons.filter((addon) => addonResults.get(addon)?.result === "failed")
+      ), { status: hasFailures ? "failed" : "success" };
     } catch (e) {
       return logger9.error("Unexpected error during addon configuration:"), logger9.error(e), { status: "failed" };
     }
@@ -1429,7 +1975,7 @@ var ADDON_INSTALLATION_INSTRUCTIONS = {
   }
   logManualAddonInstructions(addons) {
     let addonsWithInstructions = this.getAddonsWithInstructions(addons);
-    addonsWithInstructions.length > 0 && logger9.warn(import_ts_dedent8.dedent`
+    addonsWithInstructions.length > 0 && logger9.warn(import_ts_dedent9.dedent`
       The following addons couldn't be configured:
 
       ${addonsWithInstructions.map((addon) => {
@@ -1443,13 +1989,14 @@ var ADDON_INSTALLATION_INSTRUCTIONS = {
   }
   /** Configure test addons (a11y and vitest) */
   async configureAddons(configDir, addons) {
-    let { postinstallAddon } = await import("./postinstallAddon-YDLXBU2S.js"), task = prompt6.taskLog({
+    let { postinstallAddon } = await import("./postinstallAddon-SN6SHJQO.js"), task = prompt6.taskLog({
       id: "configure-addons",
       title: "Configuring addons..."
     }), addonResults = /* @__PURE__ */ new Map();
     for (let addon of addons)
       try {
-        task.message(`Configuring ${addon}...`), await postinstallAddon(addon, {
+        task.message(`Configuring ${addon}...`);
+        let options = {
           packageManager: this.packageManager.type,
           configDir,
           yes: this.commandOptions.yes,
@@ -1457,15 +2004,16 @@ var ADDON_INSTALLATION_INSTRUCTIONS = {
           skipDependencyManagement: !0,
           logger: logger9,
           prompt: prompt6
-        }), task.message(`${addon} configured
+        };
+        addon === "@storybook/addon-vitest" ? await postInstall(options) : addon === "@storybook/addon-a11y" ? await postinstall(options) : await postinstallAddon(addon, options), task.message(`${addon} configured
 `), addonResults.set(addon, null);
       } catch (e) {
-        ErrorCollector.addError(e), addonResults.set(addon, e);
+        logger9.debug(e), ErrorCollector.addError(e), addonResults.set(addon, e);
       }
     let hasFailures = [...addonResults.values()].some((result) => result !== null);
     return hasFailures ? task.error("Failed to configure addons") : task.success("Addons configured successfully"), addons.forEach((addon, index) => {
       let error = addonResults.get(addon);
-      logger9.log(CLI_COLORS2.muted(error ? `\u274C ${addon}` : `\u2705 ${addon}`), {
+      logger9.log(CLI_COLORS3.muted(error ? `\u274C ${addon}` : `\u2705 ${addon}`), {
         spacing: index === 0 ? 1 : 0
       });
     }), { hasFailures, addonResults };
@@ -1477,12 +2025,12 @@ var ADDON_INSTALLATION_INSTRUCTIONS = {
 }) => new AddonConfigurationCommand(packageManager, options).execute(rest);
 
 // src/commands/DependencyInstallationCommand.ts
-import { AddonVitestService as AddonVitestService3 } from "storybook/internal/cli";
+import { AddonVitestService as AddonVitestService4 } from "storybook/internal/cli";
 import { logger as logger10, prompt as prompt7 } from "storybook/internal/node-logger";
 import { ErrorCollector as ErrorCollector2 } from "storybook/internal/telemetry";
 import { Feature as Feature5 } from "storybook/internal/types";
 var DependencyInstallationCommand = class {
-  constructor(dependencyCollector, packageManager, addonVitestService = new AddonVitestService3(packageManager)) {
+  constructor(dependencyCollector, packageManager, addonVitestService = new AddonVitestService4(packageManager)) {
     this.dependencyCollector = dependencyCollector;
     this.packageManager = packageManager;
     this.addonVitestService = addonVitestService;
@@ -1536,11 +2084,11 @@ var DependencyInstallationCommand = class {
 }) => new DependencyInstallationCommand(dependencyCollector, packageManager).execute(props);
 
 // src/commands/FinalizationCommand.ts
-import fs from "node:fs/promises";
-import { getProjectRoot as getProjectRoot3 } from "storybook/internal/common";
-import { CLI_COLORS as CLI_COLORS3, logTracker, logger as logger11 } from "storybook/internal/node-logger";
+import fs2 from "node:fs/promises";
+import { getProjectRoot as getProjectRoot4 } from "storybook/internal/common";
+import { CLI_COLORS as CLI_COLORS4, logTracker, logger as logger11 } from "storybook/internal/node-logger";
 import { ErrorCollector as ErrorCollector3 } from "storybook/internal/telemetry";
-var import_ts_dedent9 = __toESM(require_dist(), 1), FinalizationCommand = class {
+var import_ts_dedent10 = __toESM(require_dist(), 1), FinalizationCommand = class {
   constructor(logfile) {
     this.logfile = logfile;
   }
@@ -1550,15 +2098,15 @@ var import_ts_dedent9 = __toESM(require_dist(), 1), FinalizationCommand = class
   }
   /** Update .gitignore with Storybook-specific entries */
   async updateGitignore() {
-    let foundGitIgnoreFile = up2(".gitignore"), rootDirectory = getProjectRoot3();
+    let foundGitIgnoreFile = up2(".gitignore"), rootDirectory = getProjectRoot4();
     if (!foundGitIgnoreFile || !foundGitIgnoreFile.includes(rootDirectory))
       return;
-    let contents = await fs.readFile(foundGitIgnoreFile, "utf-8"), hasStorybookLog = contents.includes("*storybook.log"), hasStorybookStatic = contents.includes("storybook-static"), linesToAdd = [
+    let contents = await fs2.readFile(foundGitIgnoreFile, "utf-8"), hasStorybookLog = contents.includes("*storybook.log"), hasStorybookStatic = contents.includes("storybook-static"), linesToAdd = [
       hasStorybookLog ? "" : "*storybook.log",
       hasStorybookStatic ? "" : "storybook-static"
     ].filter(Boolean).join(`
 `);
-    linesToAdd && await fs.appendFile(foundGitIgnoreFile, `
+    linesToAdd && await fs2.appendFile(foundGitIgnoreFile, `
 ${linesToAdd}
 `);
   }
@@ -1574,14 +2122,14 @@ ${linesToAdd}
   }
   /** Print success message with feature summary */
   printSuccessMessage(storybookCommand) {
-    logger11.step(CLI_COLORS3.success("Storybook was successfully installed in your project!")), this.printNextSteps(storybookCommand);
+    logger11.step(CLI_COLORS4.success("Storybook was successfully installed in your project!")), this.printNextSteps(storybookCommand);
   }
   printNextSteps(storybookCommand) {
     storybookCommand && logger11.log(
-      `To run Storybook manually, run ${CLI_COLORS3.cta(storybookCommand)}. CTRL+C to stop.`
-    ), logger11.log(import_ts_dedent9.dedent`
-      Wanna know more about Storybook? Check out ${CLI_COLORS3.cta("https://storybook.js.org/")}
-      Having trouble or want to chat? Join us at ${CLI_COLORS3.cta("https://discord.gg/storybook/")}
+      `To run Storybook manually, run ${CLI_COLORS4.cta(storybookCommand)}. CTRL+C to stop.`
+    ), logger11.log(import_ts_dedent10.dedent`
+      Wanna know more about Storybook? Check out ${CLI_COLORS4.cta("https://storybook.js.org/")}
+      Having trouble or want to chat? Join us at ${CLI_COLORS4.cta("https://discord.gg/storybook/")}
     `);
   }
 }, executeFinalization = ({
@@ -1622,13 +2170,13 @@ var DependencyCollector = class {
     for (let [type, typeMap] of this.packages.entries()) {
       let packageNames = /* @__PURE__ */ new Map();
       typeMap.forEach((version, name) => {
-        let versions2 = packageNames.get(name) || [];
-        versions2.push(version), packageNames.set(name, versions2);
-      }), packageNames.forEach((versions2, name) => {
-        versions2.length > 1 && new Set(versions2).size > 1 && conflicts.push({
+        let versions4 = packageNames.get(name) || [];
+        versions4.push(version), packageNames.set(name, versions4);
+      }), packageNames.forEach((versions4, name) => {
+        versions4.length > 1 && new Set(versions4).size > 1 && conflicts.push({
           packageName: name,
-          existingVersion: versions2[0],
-          newVersion: versions2[versions2.length - 1],
+          existingVersion: versions4[0],
+          newVersion: versions4[versions4.length - 1],
           type
         });
       });
@@ -1706,18 +2254,18 @@ var DependencyCollector = class {
 };
 
 // src/generators/ANGULAR/index.ts
-var import_ts_dedent10 = __toESM(require_dist(), 1);
-import { dirname as dirname3, join as join4 } from "node:path";
+var import_ts_dedent11 = __toESM(require_dist(), 1);
+import { dirname as dirname4, join as join4 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { AngularJSON, ProjectType as ProjectType4, copyTemplate } from "storybook/internal/cli";
 import { logger as logger12, prompt as prompt8 } from "storybook/internal/node-logger";
-import { SupportedBuilder as SupportedBuilder2, SupportedFramework as SupportedFramework3, SupportedRenderer } from "storybook/internal/types";
+import { SupportedBuilder as SupportedBuilder2, SupportedFramework as SupportedFramework4, SupportedRenderer } from "storybook/internal/types";
 import semver2 from "semver";
 var ANGULAR_default = {
   metadata: {
     projectType: ProjectType4.ANGULAR,
     renderer: SupportedRenderer.ANGULAR,
-    framework: SupportedFramework3.ANGULAR,
+    framework: SupportedFramework4.ANGULAR,
     builderOverride: SupportedBuilder2.WEBPACK5
   },
   configure: async (packageManager, context) => {
@@ -1752,7 +2300,7 @@ var ANGULAR_default = {
     let projectTypeValue = projectType || "application";
     projectTypeValue !== "application" && projectTypeValue !== "library" && (projectTypeValue = "application");
     let templateDir = join4(
-      dirname3(fileURLToPath2(import.meta.resolve("create-storybook/package.json"))),
+      dirname4(fileURLToPath2(import.meta.resolve("create-storybook/package.json"))),
       "templates",
       "angular",
       projectTypeValue
@@ -1784,7 +2332,7 @@ var ANGULAR_default = {
       storybookCommand: `ng run ${angularProjectName}:storybook`,
       ...useCompodoc && {
         frameworkPreviewParts: {
-          prefix: import_ts_dedent10.dedent`
+          prefix: import_ts_dedent11.dedent`
           import { setCompodocJson } from "@storybook/addon-docs/angular";
           import docJson from "../documentation.json";
           setCompodocJson(docJson);
@@ -1805,12 +2353,12 @@ function promptForCompoDocs() {
 
 // src/generators/EMBER/index.ts
 import { ProjectType as ProjectType5 } from "storybook/internal/cli";
-import { SupportedBuilder as SupportedBuilder3, SupportedFramework as SupportedFramework4, SupportedRenderer as SupportedRenderer2 } from "storybook/internal/types";
+import { SupportedBuilder as SupportedBuilder3, SupportedFramework as SupportedFramework5, SupportedRenderer as SupportedRenderer2 } from "storybook/internal/types";
 var EMBER_default = {
   metadata: {
     projectType: ProjectType5.EMBER,
     renderer: SupportedRenderer2.EMBER,
-    framework: SupportedFramework4.EMBER,
+    framework: SupportedFramework5.EMBER,
     builderOverride: SupportedBuilder3.WEBPACK5
   },
   configure: async () => ({
@@ -1832,14 +2380,14 @@ var HTML_default = {
 };
 
 // src/generators/NEXTJS/index.ts
-var import_ts_dedent11 = __toESM(require_dist(), 1);
-import { existsSync as existsSync3 } from "node:fs";
-import { readFile } from "node:fs/promises";
+var import_ts_dedent12 = __toESM(require_dist(), 1);
+import { existsSync as existsSync4 } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
 import { join as join5 } from "node:path";
 import { ProjectType as ProjectType7 } from "storybook/internal/cli";
 import { findFilesUp } from "storybook/internal/common";
 import { logger as logger13, prompt as prompt9 } from "storybook/internal/node-logger";
-import { SupportedBuilder as SupportedBuilder5, SupportedFramework as SupportedFramework5, SupportedRenderer as SupportedRenderer4 } from "storybook/internal/types";
+import { SupportedBuilder as SupportedBuilder5, SupportedFramework as SupportedFramework6, SupportedRenderer as SupportedRenderer4 } from "storybook/internal/types";
 var NEXT_CONFIG_FILES = [
   "next.config.mjs",
   "next.config.js",
@@ -1859,17 +2407,17 @@ var NEXT_CONFIG_FILES = [
   metadata: {
     projectType: ProjectType7.NEXTJS,
     renderer: SupportedRenderer4.REACT,
-    framework: (builder) => builder === SupportedBuilder5.VITE ? SupportedFramework5.NEXTJS_VITE : SupportedFramework5.NEXTJS,
+    framework: (builder) => builder === SupportedBuilder5.VITE ? SupportedFramework6.NEXTJS_VITE : SupportedFramework6.NEXTJS,
     builderOverride: async () => {
       let nextConfigFile = findFilesUp(NEXT_CONFIG_FILES, process.cwd())[0];
       if (!nextConfigFile)
         return SupportedBuilder5.VITE;
-      let hasCustomWebpackConfig = (await readFile(nextConfigFile, "utf-8")).includes("webpack"), babelConfigFile = findFilesUp(BABEL_CONFIG_FILES, process.cwd())[0];
+      let hasCustomWebpackConfig = (await readFile2(nextConfigFile, "utf-8")).includes("webpack"), babelConfigFile = findFilesUp(BABEL_CONFIG_FILES, process.cwd())[0];
       if (!hasCustomWebpackConfig && !babelConfigFile)
         return SupportedBuilder5.VITE;
       {
         let reason = hasCustomWebpackConfig && babelConfigFile ? "custom webpack config and babel config" : hasCustomWebpackConfig ? "custom webpack config" : "custom babel config";
-        return logger13.info(import_ts_dedent11.dedent`
+        return logger13.info(import_ts_dedent12.dedent`
           Storybook has two Next.js builder options: Webpack 5 and Vite.
           
           We generally recommend nextjs-vite, which is much faster, more modern, and supports our latest testing features.
@@ -1887,7 +2435,7 @@ var NEXT_CONFIG_FILES = [
   },
   configure: async (packageManager, context) => {
     let staticDir;
-    existsSync3(join5(process.cwd(), "public")) && (staticDir = "public");
+    existsSync4(join5(process.cwd(), "public")) && (staticDir = "public");
     let extraPackages = [];
     return context.builder === SupportedBuilder5.VITE && extraPackages.push("vite"), {
       staticDir,
@@ -1902,14 +2450,14 @@ import { logger as logger14 } from "storybook/internal/node-logger";
 import {
   Feature as Feature6,
   SupportedBuilder as SupportedBuilder6,
-  SupportedFramework as SupportedFramework6,
+  SupportedFramework as SupportedFramework7,
   SupportedRenderer as SupportedRenderer5
 } from "storybook/internal/types";
 var NUXT_default = {
   metadata: {
     projectType: ProjectType8.NUXT,
     renderer: SupportedRenderer5.VUE3,
-    framework: SupportedFramework6.NUXT,
+    framework: SupportedFramework7.NUXT,
     builderOverride: SupportedBuilder6.VITE
   },
   configure: async (packageManager, context) => {
@@ -1944,12 +2492,12 @@ var PREACT_default = {
 
 // src/generators/QWIK/index.ts
 import { ProjectType as ProjectType10 } from "storybook/internal/cli";
-import { SupportedFramework as SupportedFramework7, SupportedRenderer as SupportedRenderer7 } from "storybook/internal/types";
+import { SupportedFramework as SupportedFramework8, SupportedRenderer as SupportedRenderer7 } from "storybook/internal/types";
 var QWIK_default = {
   metadata: {
     projectType: ProjectType10.QWIK,
     renderer: SupportedRenderer7.QWIK,
-    framework: SupportedFramework7.QWIK
+    framework: SupportedFramework8.QWIK
   },
   configure: async () => ({})
 };
@@ -1969,9 +2517,9 @@ var REACT_default = {
 };
 
 // src/generators/REACT_NATIVE/index.ts
-var import_ts_dedent12 = __toESM(require_dist(), 1);
+var import_ts_dedent13 = __toESM(require_dist(), 1);
 import { ProjectType as ProjectType12, copyTemplateFiles as copyTemplateFiles2, getBabelDependencies } from "storybook/internal/cli";
-import { CLI_COLORS as CLI_COLORS4, logger as logger15 } from "storybook/internal/node-logger";
+import { CLI_COLORS as CLI_COLORS5, logger as logger15 } from "storybook/internal/node-logger";
 import { SupportedBuilder as SupportedBuilder9, SupportedLanguage as SupportedLanguage5, SupportedRenderer as SupportedRenderer9 } from "storybook/internal/types";
 var REACT_NATIVE_default = {
   metadata: {
@@ -2021,33 +2569,33 @@ var REACT_NATIVE_default = {
     };
   },
   postConfigure: ({ packageManager }) => {
-    logger15.log(import_ts_dedent12.dedent`
-      ${CLI_COLORS4.warning("The Storybook for React Native installation is not 100% automated.")}
+    logger15.log(import_ts_dedent13.dedent`
+      ${CLI_COLORS5.warning("The Storybook for React Native installation is not 100% automated.")}
   
       To run Storybook for React Native, you will need to:
   
       1. Replace the contents of your app entry with the following
   
-      ${CLI_COLORS4.info(" export {default} from './.rnstorybook'; ")}
+      ${CLI_COLORS5.info(" export {default} from './.rnstorybook'; ")}
   
       2. Wrap your metro config with the withStorybook enhancer function like this:
   
-      ${CLI_COLORS4.info(" const { withStorybook } = require('@storybook/react-native/metro/withStorybook'); ")}
-      ${CLI_COLORS4.info(" module.exports = withStorybook(defaultConfig); ")}
+      ${CLI_COLORS5.info(" const { withStorybook } = require('@storybook/react-native/metro/withStorybook'); ")}
+      ${CLI_COLORS5.info(" module.exports = withStorybook(defaultConfig); ")}
   
       For more details go to:
       https://github.com/storybookjs/react-native#getting-started
   
       Then to start Storybook for React Native, run:
   
-      ${CLI_COLORS4.cta(" " + packageManager.getRunCommand("start") + " ")}
+      ${CLI_COLORS5.cta(" " + packageManager.getRunCommand("start") + " ")}
     `);
   }
 };
 
 // src/generators/REACT_NATIVE_AND_RNW/index.ts
 import { ProjectType as ProjectType14 } from "storybook/internal/cli";
-import { SupportedBuilder as SupportedBuilder11, SupportedFramework as SupportedFramework9, SupportedRenderer as SupportedRenderer11 } from "storybook/internal/types";
+import { SupportedBuilder as SupportedBuilder11, SupportedFramework as SupportedFramework10, SupportedRenderer as SupportedRenderer11 } from "storybook/internal/types";
 
 // src/generators/REACT_NATIVE_WEB/index.ts
 import { readdir, rm as rm2 } from "node:fs/promises";
@@ -2055,7 +2603,7 @@ import { join as join6 } from "node:path";
 import { ProjectType as ProjectType13, cliStoriesTargetPath } from "storybook/internal/cli";
 import {
   SupportedBuilder as SupportedBuilder10,
-  SupportedFramework as SupportedFramework8,
+  SupportedFramework as SupportedFramework9,
   SupportedLanguage as SupportedLanguage6,
   SupportedRenderer as SupportedRenderer10
 } from "storybook/internal/types";
@@ -2063,7 +2611,7 @@ var REACT_NATIVE_WEB_default = {
   metadata: {
     projectType: ProjectType13.REACT_NATIVE_WEB,
     renderer: SupportedRenderer10.REACT,
-    framework: SupportedFramework8.REACT_NATIVE_WEB_VITE,
+    framework: SupportedFramework9.REACT_NATIVE_WEB_VITE,
     builderOverride: SupportedBuilder10.VITE
   },
   configure: async (packageManager, { language }) => {
@@ -2086,7 +2634,7 @@ var REACT_NATIVE_AND_RNW_default = {
   metadata: {
     projectType: ProjectType14.REACT_NATIVE_AND_RNW,
     renderer: SupportedRenderer11.REACT,
-    framework: SupportedFramework9.REACT_NATIVE_WEB_VITE,
+    framework: SupportedFramework10.REACT_NATIVE_WEB_VITE,
     builderOverride: SupportedBuilder11.VITE
   },
   configure: async (packageManager, context) => (await REACT_NATIVE_default.configure(packageManager, context), {
@@ -2103,9 +2651,9 @@ var REACT_NATIVE_AND_RNW_default = {
 };
 
 // src/generators/REACT_SCRIPTS/index.ts
-var import_ts_dedent13 = __toESM(require_dist(), 1);
-import { existsSync as existsSync4 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
+var import_ts_dedent14 = __toESM(require_dist(), 1);
+import { existsSync as existsSync5 } from "node:fs";
+import { resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { ProjectType as ProjectType15 } from "storybook/internal/cli";
 import { SupportedBuilder as SupportedBuilder12, SupportedRenderer as SupportedRenderer12 } from "storybook/internal/types";
@@ -2130,12 +2678,12 @@ var REACT_SCRIPTS_default = {
       %%`
     } : {}, craVersion = (await packageManager.getModulePackageJSON("react-scripts"))?.version ?? null;
     if (craVersion === null)
-      throw new Error(import_ts_dedent13.dedent`
+      throw new Error(import_ts_dedent14.dedent`
         It looks like you're trying to initialize Storybook in a CRA project that does not have react-scripts installed.
         Please install it and make sure it's of version 5 or higher, which are the versions supported by Storybook 7.0+.
       `);
     if (craVersion && semver3.lt(craVersion, "5.0.0"))
-      throw new Error(import_ts_dedent13.dedent`
+      throw new Error(import_ts_dedent14.dedent`
         Storybook 7.0+ doesn't support react-scripts@<5.0.0.
   
         https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#create-react-app-dropped-cra4-support
@@ -2145,7 +2693,7 @@ var REACT_SCRIPTS_default = {
       },
       extraAddons: ["@storybook/preset-create-react-app"],
       extraPackages: ["webpack", "prop-types"],
-      staticDir: existsSync4(resolve4("./public")) ? "public" : void 0,
+      staticDir: existsSync5(resolve5("./public")) ? "public" : void 0,
       extraMain
     };
   }
@@ -2168,12 +2716,12 @@ var SERVER_default = {
 
 // src/generators/SOLID/index.ts
 import { ProjectType as ProjectType17 } from "storybook/internal/cli";
-import { SupportedBuilder as SupportedBuilder14, SupportedFramework as SupportedFramework10, SupportedRenderer as SupportedRenderer14 } from "storybook/internal/types";
+import { SupportedBuilder as SupportedBuilder14, SupportedFramework as SupportedFramework11, SupportedRenderer as SupportedRenderer14 } from "storybook/internal/types";
 var SOLID_default = {
   metadata: {
     projectType: ProjectType17.SOLID,
     renderer: SupportedRenderer14.SOLID,
-    framework: SupportedFramework10.SOLID,
+    framework: SupportedFramework11.SOLID,
     builderOverride: SupportedBuilder14.VITE
   },
   configure: async () => ({
@@ -2197,12 +2745,12 @@ var SVELTE_default = {
 
 // src/generators/SVELTEKIT/index.ts
 import { ProjectType as ProjectType19 } from "storybook/internal/cli";
-import { SupportedBuilder as SupportedBuilder15, SupportedFramework as SupportedFramework11, SupportedRenderer as SupportedRenderer16 } from "storybook/internal/types";
+import { SupportedBuilder as SupportedBuilder15, SupportedFramework as SupportedFramework12, SupportedRenderer as SupportedRenderer16 } from "storybook/internal/types";
 var SVELTEKIT_default = {
   metadata: {
     projectType: ProjectType19.SVELTEKIT,
     renderer: SupportedRenderer16.SVELTE,
-    framework: SupportedFramework11.SVELTEKIT,
+    framework: SupportedFramework12.SVELTEKIT,
     builderOverride: SupportedBuilder15.VITE
   },
   configure: async () => ({
@@ -2298,7 +2846,6 @@ async function doInitiate(options) {
     packageManager,
     addons: extraAddons,
     configDir,
-    dependencyInstallationResult,
     options
   }), await executeFinalization({
     logfile: options.logfile,