@storybook/cli 10.1.0-alpha.9 → 10.1.0-beta.1

package/dist/_node-chunks/chunk-H7CKG54H.js

@@ -0,0 +1,45 @@
+import CJS_COMPAT_NODE_URL_7na3jaknjbu from 'node:url';
+import CJS_COMPAT_NODE_PATH_7na3jaknjbu from 'node:path';
+import CJS_COMPAT_NODE_MODULE_7na3jaknjbu from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_7na3jaknjbu.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_7na3jaknjbu.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_7na3jaknjbu.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(x, {
+  get: (a, b) => (typeof require < "u" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require < "u") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/_node-chunks/chunk-IMEW6HKQ.js

@@ -0,0 +1,11 @@
+import CJS_COMPAT_NODE_URL_7na3jaknjbu from 'node:url';
+import CJS_COMPAT_NODE_PATH_7na3jaknjbu from 'node:path';
+import CJS_COMPAT_NODE_MODULE_7na3jaknjbu from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_7na3jaknjbu.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_7na3jaknjbu.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_7na3jaknjbu.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------

package/dist/_node-chunks/chunk-OVP33YUF.js

@@ -0,0 +1,591 @@
+import CJS_COMPAT_NODE_URL_7na3jaknjbu from 'node:url';
+import CJS_COMPAT_NODE_PATH_7na3jaknjbu from 'node:path';
+import CJS_COMPAT_NODE_MODULE_7na3jaknjbu from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_7na3jaknjbu.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_7na3jaknjbu.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_7na3jaknjbu.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  globby,
+  globbySync
+} from "./chunk-YET6YMCR.js";
+import {
+  require_semver
+} from "./chunk-B52WZYLE.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-H7CKG54H.js";
+
+// ../../node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/picocolors/picocolors.js"(exports, module) {
+    var p = process || {}, argv = p.argv || [], env = p.env || {}, isColorSupported = !(env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI), formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    }, replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do
+        result += string.substring(cursor, index) + replace, cursor = index + close.length, index = string.indexOf(close, cursor);
+      while (~index);
+      return result + string.substring(cursor);
+    }, createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/autoblock/utils.ts
+var import_semver2 = __toESM(require_semver(), 1);
+import { CLI_COLORS } from "storybook/internal/node-logger";
+
+// src/util.ts
+import { HandledError, JsPackageManager, normalizeStories } from "storybook/internal/common";
+import { getProjectRoot, isSatelliteAddon, versions } from "storybook/internal/common";
+import { StoryIndexGenerator, experimental_loadStorybook } from "storybook/internal/core-server";
+import { logTracker, logger as logger2, prompt } from "storybook/internal/node-logger";
+import {
+  UpgradeStorybookToLowerVersionError,
+  UpgradeStorybookUnknownCurrentVersionError
+} from "storybook/internal/server-errors";
+
+// ../../node_modules/empathic/walk.mjs
+import { dirname } from "node:path";
+
+// ../../node_modules/empathic/resolve.mjs
+import { isAbsolute, join, resolve } from "node:path";
+function absolute(input, root) {
+  return isAbsolute(input) ? input : resolve(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); )
+    ;
+  return arr;
+}
+
+// src/util.ts
+var import_picocolors2 = __toESM(require_picocolors(), 1), import_semver = __toESM(require_semver(), 1);
+
+// src/autoblock/index.ts
+var blockers = () => [
+  // add/remove blockers here
+  import("./block-dependencies-versions-RWX4DX7W.js"),
+  import("./block-node-version-IVL2SO4R.js"),
+  import("./block-webpack5-frameworks-DRJJONK4.js"),
+  import("./block-major-version-7X5ELMS5.js"),
+  import("./block-experimental-addon-test-OM3MVIEF.js")
+], autoblock = async (options, list = blockers()) => list.length === 0 ? null : await Promise.all(
+  list.map(async (i) => {
+    let blocker = (await i).blocker;
+    return { result: await blocker.check(options), blocker };
+  })
+);
+
+// src/automigrate/helpers/mainConfigFile.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, normalize } from "node:path";
+import {
+  JsPackageManagerFactory,
+  builderPackages,
+  extractFrameworkPackageName,
+  frameworkPackages,
+  getStorybookInfo
+} from "storybook/internal/common";
+import { frameworkToRenderer, getCoercedStorybookVersion } from "storybook/internal/common";
+import { readConfig, writeConfig as writeConfigFile } from "storybook/internal/csf-tools";
+import { logger } from "storybook/internal/node-logger";
+var getFrameworkPackageName = (mainConfig) => {
+  let packageNameOrPath = typeof mainConfig?.framework == "string" ? mainConfig.framework : mainConfig?.framework?.name;
+  return packageNameOrPath ? extractFrameworkPackageName(packageNameOrPath) : null;
+};
+var getStorybookData = async ({
+  configDir: userDefinedConfigDir,
+  cwd,
+  packageManagerName
+}) => {
+  logger.debug("Getting Storybook info...");
+  let {
+    mainConfig,
+    mainConfigPath,
+    configDir: configDirFromScript,
+    previewConfigPath
+  } = await getStorybookInfo(userDefinedConfigDir, cwd), configDir = userDefinedConfigDir || configDirFromScript || ".storybook";
+  logger.debug("Loading main config...");
+  let workingDir = isAbsolute2(configDir) ? dirname2(configDir) : dirname2(join2(cwd ?? process.cwd(), configDir));
+  logger.debug("Getting stories paths...");
+  let storiesPaths = await getStoriesPathsFromConfig({
+    stories: mainConfig.stories,
+    configDir,
+    workingDir
+  });
+  logger.debug("Getting package manager...");
+  let packageManager = JsPackageManagerFactory.getPackageManager({
+    force: packageManagerName,
+    configDir,
+    storiesPaths
+  });
+  logger.debug("Getting Storybook version...");
+  let storybookVersion = await getCoercedStorybookVersion(packageManager);
+  return {
+    configDir,
+    mainConfig,
+    storybookVersion,
+    mainConfigPath,
+    previewConfigPath,
+    packageManager,
+    storiesPaths
+  };
+}, updateMainConfig = async ({ mainConfigPath, dryRun }, callback) => {
+  try {
+    let main = await readConfig(mainConfigPath);
+    await callback(main), dryRun || await writeConfigFile(main);
+  } catch (e) {
+    logger.log(
+      `\u274C The migration failed to update your ${import_picocolors.default.blue(
+        mainConfigPath
+      )} on your behalf because of the following error:
+        ${e}
+`
+    ), logger.log(
+      `\u26A0\uFE0F Storybook automigrations are based on AST parsing and it's possible that your ${import_picocolors.default.blue(
+        mainConfigPath
+      )} file contains a non-standard format (e.g. your export is not an object) or that there was an error when parsing dynamic values (e.g. "require" calls, or usage of environment variables). When your main config is non-standard, automigrations are unfortunately not possible. Please follow the instructions given previously and follow the documentation to make the updates manually.`
+    );
+  }
+};
+function containsESMUsage(content) {
+  let hasImportStatement = /^\s*import\s+/m.test(content) || /^\s*import\s*{/m.test(content) || /^\s*import\s*\(/m.test(content), hasExportStatement = /^\s*export\s+/m.test(content) || /^\s*export\s*{/m.test(content) || /^\s*export\s*default/m.test(content), hasImportMeta = /import\.meta/.test(content);
+  return hasImportStatement || hasExportStatement || hasImportMeta;
+}
+function containsRequireUsage(content) {
+  let requireCallRegex = /\brequire\(/, requireDotRegex = /\brequire\./;
+  return requireCallRegex.test(content) || requireDotRegex.test(content);
+}
+function containsPatternUsage(content, pattern) {
+  let cleanContent = ((s) => s.replace(/(['"`])(?:\\.|(?!\1)[\s\S])*?\1/g, '""'))(content).replace(/\/\*[\s\S]*?\*\//g, "").split(`
+`).map((line) => line.split("//")[0]).join(`
+`);
+  return pattern.test(cleanContent);
+}
+function containsDirnameUsage(content) {
+  return containsPatternUsage(content, /\b__dirname\b/);
+}
+function containsFilenameUsage(content) {
+  return containsPatternUsage(content, /\b__filename\b/);
+}
+var bannerComment = "// This file has been automatically migrated to valid ESM format by Storybook.", hasRequireBanner = (content) => content.includes(bannerComment);
+
+// src/util.ts
+var STORYBOOK_DIR_PATTERN = ["**/.storybook", "**/.rnstorybook"], isSuccessResult = (result) => !("error" in result), isErrorResult = (result) => "error" in result, getVersionModifier = (versionSpecifier) => {
+  if (!versionSpecifier || typeof versionSpecifier != "string")
+    return { modifier: "", useFixed: !0 };
+  let firstPart = versionSpecifier.split(/\s*\|\|\s*/)[0]?.trim();
+  if (!firstPart)
+    return { modifier: "", useFixed: !0 };
+  let modifier = firstPart.match(/^([~^><=]+)/)?.[1] ?? "";
+  return {
+    modifier,
+    useFixed: !modifier
+  };
+}, isCanaryVersion = (version) => version.startsWith("0.0.0") || version.startsWith("portal:") || version.startsWith("workspace:");
+function validateVersion(version) {
+  if (!version)
+    throw new UpgradeStorybookUnknownCurrentVersionError();
+}
+var validateUpgradeCompatibility = (currentVersion, beforeVersion, isCanary) => {
+  if (!isCanary && (0, import_semver.lt)(currentVersion, beforeVersion))
+    throw new UpgradeStorybookToLowerVersionError({
+      beforeVersion,
+      currentVersion
+    });
+}, findStorybookProjects = async (cwd = process.cwd()) => {
+  try {
+    logger2.debug("Finding Storybook projects...");
+    let storybookDirs = await globby(STORYBOOK_DIR_PATTERN, {
+      cwd,
+      dot: !0,
+      gitignore: !0,
+      absolute: !0,
+      onlyDirectories: !0,
+      followSymbolicLinks: !1
+    });
+    return logger2.debug(`Found ${storybookDirs.length} Storybook projects`), storybookDirs.length === 0 ? [await prompt.text({
+      message: "No Storybook projects were found. Please enter the path to the .storybook directory for the project you want to upgrade."
+    })] : storybookDirs;
+  } catch (error) {
+    throw logger2.error("Failed to find Storybook projects"), error;
+  }
+};
+var processProject = async ({
+  configDir,
+  options,
+  currentCLIVersion,
+  onScanStart
+}) => {
+  try {
+    onScanStart();
+    let name = configDir.replace(getProjectRoot(), "");
+    logger2.debug("Getting Storybook data...");
+    let {
+      configDir: resolvedConfigDir,
+      mainConfig,
+      mainConfigPath,
+      packageManager,
+      previewConfigPath,
+      storiesPaths,
+      storybookVersion: beforeVersion
+    } = await getStorybookData({ configDir });
+    logger2.debug(`${name} - Validating before version... ${beforeVersion}`), validateVersion(beforeVersion);
+    let isCanary = isCanaryVersion(currentCLIVersion) || isCanaryVersion(beforeVersion);
+    logger2.debug(`${name} - Validating upgrade compatibility...`), validateUpgradeCompatibility(currentCLIVersion, beforeVersion, isCanary), logger2.debug(`${name} - Fetching NPM version information...`);
+    let [latestCLIVersionOnNPM, latestPrereleaseCLIVersionOnNPM] = await Promise.all([
+      packageManager.latestVersion("storybook"),
+      packageManager.latestVersion("storybook@next")
+    ]), isCLIOutdated = (0, import_semver.lt)(currentCLIVersion, latestCLIVersionOnNPM), isCLIExactLatest = currentCLIVersion === latestCLIVersionOnNPM, isCLIPrerelease = (0, import_semver.prerelease)(currentCLIVersion) !== null, isCLIExactPrerelease = currentCLIVersion === latestPrereleaseCLIVersionOnNPM, isUpgrade = (0, import_semver.lt)(beforeVersion, currentCLIVersion), autoblockerCheckResults = null;
+    return typeof mainConfig != "boolean" && typeof mainConfigPath < "u" && !options.force && (logger2.debug(`${name} - Evaluating blockers...`), autoblockerCheckResults = await autoblock({
+      packageManager,
+      configDir: resolvedConfigDir,
+      mainConfig,
+      mainConfigPath
+    })), {
+      configDir: resolvedConfigDir,
+      mainConfig,
+      mainConfigPath,
+      packageManager,
+      isCanary,
+      isCLIOutdated,
+      isCLIPrerelease,
+      isCLIExactLatest,
+      isUpgrade,
+      beforeVersion,
+      currentCLIVersion,
+      latestCLIVersionOnNPM,
+      isCLIExactPrerelease,
+      autoblockerCheckResults,
+      previewConfigPath,
+      storiesPaths
+    };
+  } catch (error) {
+    return logger2.debug(String(error)), {
+      configDir,
+      error
+    };
+  }
+}, collectProjects = async (options, configDirs, onProjectScanStart) => {
+  let { default: pLimit } = await import("./p-limit-DCVNL4HF.js"), currentCLIVersion = versions.storybook, limit = pLimit(5), projectPromises = configDirs.map(
+    (configDir) => limit(
+      () => processProject({
+        configDir,
+        options,
+        currentCLIVersion,
+        onScanStart: () => onProjectScanStart()
+      })
+    )
+  );
+  return await Promise.all(projectPromises);
+}, generateUpgradeSpecs = async (dependencies = {}, config) => {
+  let {
+    packageManager,
+    isCanary,
+    isCLIOutdated,
+    isCLIPrerelease,
+    isCLIExactPrerelease,
+    isCLIExactLatest
+  } = config, storybookCoreUpgrades = Object.keys(dependencies).filter(
+    (dependency) => dependency in versions
+  ).map((dependency) => {
+    let versionSpec = dependencies[dependency];
+    if (!versionSpec)
+      return `${dependency}@${versions[dependency]}`;
+    let { modifier } = getVersionModifier(versionSpec);
+    return `${dependency}@${isCLIOutdated || isCanary ? "" : modifier}${versions[dependency]}`;
+  }), storybookSatelliteUpgrades = [];
+  if (isCLIExactPrerelease || isCLIExactLatest) {
+    let satelliteDependencies = Object.keys(dependencies).filter(isSatelliteAddon);
+    if (satelliteDependencies.length > 0)
+      try {
+        let upgradePromises = satelliteDependencies.map(async (dependency) => {
+          try {
+            let packageName = isCLIPrerelease ? `${dependency}@next` : dependency, mostRecentVersion = await packageManager.latestVersion(packageName);
+            if (!mostRecentVersion)
+              return null;
+            let { modifier } = getVersionModifier(dependencies[dependency] ?? "");
+            return `${dependency}@${modifier}${mostRecentVersion}`;
+          } catch {
+            return null;
+          }
+        });
+        storybookSatelliteUpgrades = (await Promise.all(upgradePromises)).filter((result) => result !== null);
+      } catch {
+        logger2.warn("Failed to fetch satellite dependencies");
+      }
+  }
+  return [...storybookCoreUpgrades, ...storybookSatelliteUpgrades];
+}, upgradeStorybookDependencies = async (config) => {
+  let { packageManager } = config;
+  for (let packageJsonPath of packageManager.packageJsonPaths) {
+    let packageJson = JsPackageManager.getPackageJson(packageJsonPath), [upgradedDependencies, upgradedDevDependencies, upgradedPeerDependencies] = await Promise.all([
+      generateUpgradeSpecs(packageJson.dependencies, config),
+      generateUpgradeSpecs(packageJson.devDependencies, config),
+      generateUpgradeSpecs(packageJson.peerDependencies, config)
+    ]);
+    logger2.debug(JSON.stringify({ upgradedDependencies }, null, 2)), logger2.debug(JSON.stringify({ upgradedDevDependencies }, null, 2)), logger2.debug(JSON.stringify({ upgradedPeerDependencies }, null, 2)), await packageManager.addDependencies(
+      {
+        type: "dependencies",
+        skipInstall: !0,
+        packageJsonInfo: JsPackageManager.getPackageJsonInfo(packageJsonPath)
+      },
+      upgradedDependencies
+    ), await packageManager.addDependencies(
+      {
+        type: "devDependencies",
+        skipInstall: !0,
+        packageJsonInfo: JsPackageManager.getPackageJsonInfo(packageJsonPath)
+      },
+      upgradedDevDependencies
+    ), await packageManager.addDependencies(
+      {
+        type: "peerDependencies",
+        skipInstall: !0,
+        packageJsonInfo: JsPackageManager.getPackageJsonInfo(packageJsonPath)
+      },
+      upgradedPeerDependencies
+    );
+  }
+}, formatProjectDirectories = (projectData, modifier) => projectData.length === 0 ? "" : projectData.map((project) => project.configDir).map((dir) => `${modifier} ${import_picocolors2.default.cyan(shortenPath(dir))}`).join(`
+`), shortenPath = (path) => {
+  let gitRoot = getProjectRoot();
+  return path.replace(gitRoot, "");
+}, handleMultipleProjects = async (validProjects, errorProjects, detectedConfigDirs, yes) => {
+  let allPackageJsonPaths = validProjects.flatMap((data) => data.packageManager.packageJsonPaths).filter(JsPackageManager.hasAnyStorybookDependency);
+  if (new Set(allPackageJsonPaths).size !== allPackageJsonPaths.length) {
+    let projectsFoundMessage = [
+      "Multiple Storybook projects found. Storybook can only upgrade all projects at once:"
+    ];
+    if (validProjects.length > 0 && projectsFoundMessage.push(formatProjectDirectories(validProjects, logger2.SYMBOLS.success)), errorProjects.length > 0 && (logTracker.enableLogWriting(), projectsFoundMessage.push(
+      `There were some errors while collecting data for the following projects:
+${formatProjectDirectories(errorProjects, logger2.SYMBOLS.error)}`,
+      "",
+      "Full logs will be available in the Storybook debug logs at the end of the run."
+    )), logger2.log(projectsFoundMessage.join(`
+`)), !(yes || await prompt.confirm({
+      message: "Continue with the upgrade?",
+      initialValue: !0
+    })))
+      throw new HandledError("Upgrade cancelled by user");
+    return [...validProjects];
+  }
+  if (detectedConfigDirs.length > 1) {
+    let selectedConfigDirs = await prompt.multiselect({
+      message: "Select which projects to upgrade",
+      options: detectedConfigDirs.map((configDir) => ({
+        label: shortenPath(configDir),
+        value: configDir
+      }))
+    });
+    return validProjects.filter((data) => selectedConfigDirs.includes(data.configDir));
+  }
+}, getProjects = async (options) => {
+  try {
+    let task = prompt.spinner({ id: "detect-projects" });
+    task.start("Detecting projects...");
+    let detectedConfigDirs = options.configDir ?? [];
+    (!options.configDir || options.configDir.length === 0) && (detectedConfigDirs = await findStorybookProjects());
+    let count = 0, projects = await collectProjects(
+      options,
+      detectedConfigDirs,
+      () => task.message(`Detecting projects: ${++count} projects`)
+    );
+    task.stop(`${projects.length} ${projects.length > 1 ? "projects" : "project"} detected`);
+    let validProjects = projects.filter(isSuccessResult), errorProjects = projects.filter(isErrorResult);
+    if (logger2.debug(
+      `Found ${validProjects.length} valid projects and ${errorProjects.length} error projects`
+    ), validProjects.length === 1)
+      return { allProjects: validProjects, selectedProjects: validProjects };
+    if (validProjects.length === 0 && errorProjects.length > 0) {
+      let errorMessage = errorProjects.map((project) => `${shortenPath(project.configDir)}:
+${project.error.stack || project.error.message}`).join(`
+`);
+      throw new Error(
+        `\u274C Storybook found errors while collecting data for the following projects:
+${errorMessage}
+Please fix the errors and run the upgrade command again.`
+      );
+    }
+    let selectedProjects = await handleMultipleProjects(
+      validProjects,
+      errorProjects,
+      detectedConfigDirs,
+      options.yes
+    );
+    return selectedProjects ? { allProjects: validProjects, selectedProjects } : void 0;
+  } catch (error) {
+    throw error instanceof HandledError || logger2.error("Failed to get projects"), error;
+  }
+}, findFilesUp = (matchers, cwd) => {
+  let matchingFiles = [];
+  for (let directory of up(cwd, { last: getProjectRoot() }))
+    matchingFiles.push(
+      ...globbySync(matchers, {
+        gitignore: !0,
+        absolute: !0,
+        cwd: directory
+      })
+    );
+  return matchingFiles;
+};
+var getStoriesPathsFromConfig = async ({
+  stories,
+  configDir,
+  workingDir
+}) => {
+  if (stories.length === 0)
+    return [];
+  let normalizedStories = normalizeStories(stories, {
+    configDir,
+    workingDir
+  });
+  return (await StoryIndexGenerator.findMatchingFilesForSpecifiers(
+    normalizedStories,
+    workingDir,
+    !0
+  )).flatMap(([specifier, cache]) => StoryIndexGenerator.storyFileNames(/* @__PURE__ */ new Map([[specifier, cache]])));
+};
+
+// src/autoblock/utils.ts
+var typedKeys = (obj) => Object.keys(obj);
+async function findOutdatedPackage(minimalVersionsMap, options) {
+  return (await Promise.all(
+    typedKeys(minimalVersionsMap).map(async (packageName) => ({
+      packageName,
+      installedVersion: (await options.packageManager.getModulePackageJSON(packageName))?.version ?? null,
+      minimumVersion: minimalVersionsMap[packageName]
+    }))
+  )).reduce(
+    (acc, { installedVersion, minimumVersion, packageName }) => acc || (packageName && installedVersion && (0, import_semver2.lt)(installedVersion, minimumVersion) ? {
+      installedVersion,
+      packageName,
+      minimumVersion
+    } : acc),
+    !1
+  );
+}
+function processAutoblockerResults(projects, onError) {
+  let autoblockerMessagesMap = /* @__PURE__ */ new Map();
+  projects.forEach((result) => {
+    result.autoblockerCheckResults?.forEach((blocker) => {
+      if (blocker.result === null || blocker.result === !1)
+        return;
+      let blockerResult = blocker.blocker.log(blocker.result), message = blockerResult.message, link = blockerResult.link;
+      autoblockerMessagesMap.has(message) ? autoblockerMessagesMap.get(message).configDirs.push(result.configDir) : autoblockerMessagesMap.set(message, {
+        title: blockerResult.title,
+        message,
+        link,
+        configDirs: [result.configDir]
+      });
+    });
+  });
+  let autoblockerMessages = Array.from(autoblockerMessagesMap.values());
+  if (autoblockerMessages.length > 0) {
+    let formatConfigDirs = (configDirs) => {
+      let baseMessage = "Affected projects:", relativeDirs = configDirs.map((dir) => shortenPath(dir) || ".");
+      if (relativeDirs.length <= 3)
+        return `${baseMessage} ${relativeDirs.join(", ")}`;
+      let remaining = relativeDirs.length - 3;
+      return `${baseMessage} ${relativeDirs.slice(0, 3).join(", ")}${remaining > 0 ? ` and ${remaining} more...` : ""}`;
+    }, formattedMessages = autoblockerMessages.map((item) => {
+      let message = `${CLI_COLORS.warning(item.title)}
+
+${item.message}
+
+${formatConfigDirs(item.configDirs)}`;
+      return item.link && (message += `
+
+More information: ${item.link}`), message;
+    });
+    return onError(
+      `Storybook has found potential blockers that need to be resolved before upgrading:
+
+${[...formattedMessages].join(`
+
+`)}
+
+---
+
+After addressing this, you can try running the upgrade command again. You can also rerun the upgrade command with the ${CLI_COLORS.info("--force")} flag to skip the blocker check and to proceed with the upgrade.`
+    ), !0;
+  }
+  return !1;
+}
+
+export {
+  require_picocolors,
+  findOutdatedPackage,
+  processAutoblockerResults,
+  upgradeStorybookDependencies,
+  shortenPath,
+  getProjects,
+  findFilesUp,
+  getFrameworkPackageName,
+  getStorybookData,
+  updateMainConfig,
+  containsESMUsage,
+  containsRequireUsage,
+  containsDirnameUsage,
+  containsFilenameUsage,
+  bannerComment,
+  hasRequireBanner
+};