@storybook/cli 7.0.0-beta.60 → 7.0.0-beta.61

package/dist/chunk-HBVTX4IN.mjs

@@ -0,0 +1,1239 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/js-package-manager/deprecations.ts
+import deprecate from "util-deprecate";
+var useNpmWarning = deprecate(
+  () => {
+  },
+  `\`--use-npm\` is deprecated and will be removed in Storybook 8.0. 
+Please use the \`--package-manager=npm\` option instead.
+Read more at https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#cli-option---use-npm-deprecated`
+);
+
+// src/js-package-manager/JsPackageManager.ts
+import chalk2 from "chalk";
+import { gt, satisfies as satisfies2 } from "semver";
+import { sync as spawnSync } from "cross-spawn";
+import path2 from "path";
+import fs2 from "fs";
+
+// src/helpers.ts
+import path, { join as join2 } from "path";
+import fs from "fs";
+import fse from "fs-extra";
+import chalk from "chalk";
+import { satisfies } from "semver";
+import stripJsonComments from "strip-json-comments";
+
+// src/dirs.ts
+import { dirname, join } from "path";
+import downloadTarball from "@ndelangen/get-tarball";
+import getNpmTarballUrl from "get-npm-tarball-url";
+import * as tempy from "tempy";
+
+// src/project_types.ts
+import { minVersion, validRange } from "semver";
+function ltMajor(versionRange, major) {
+  return validRange(versionRange) && minVersion(versionRange).major < major;
+}
+function gtMajor(versionRange, major) {
+  return validRange(versionRange) && minVersion(versionRange).major > major;
+}
+function eqMajor(versionRange, major) {
+  return validRange(versionRange) && minVersion(versionRange).major === major;
+}
+var externalFrameworks = [
+  { name: "qwik", packageName: "storybook-framework-qwik" },
+  { name: "solid", frameworks: ["storybook-solidjs-vite"], renderer: "storybook-solidjs" }
+];
+var SUPPORTED_RENDERERS = [
+  "react",
+  "react-native",
+  "vue",
+  "vue3",
+  "angular",
+  "mithril",
+  "riot",
+  "ember",
+  "marionette",
+  "marko",
+  "preact",
+  "svelte",
+  "qwik",
+  "rax",
+  "aurelia",
+  "solid"
+];
+var ProjectType = /* @__PURE__ */ ((ProjectType2) => {
+  ProjectType2["UNDETECTED"] = "UNDETECTED";
+  ProjectType2["UNSUPPORTED"] = "UNSUPPORTED";
+  ProjectType2["REACT_SCRIPTS"] = "REACT_SCRIPTS";
+  ProjectType2["REACT"] = "REACT";
+  ProjectType2["REACT_NATIVE"] = "REACT_NATIVE";
+  ProjectType2["REACT_PROJECT"] = "REACT_PROJECT";
+  ProjectType2["WEBPACK_REACT"] = "WEBPACK_REACT";
+  ProjectType2["NEXTJS"] = "NEXTJS";
+  ProjectType2["VUE"] = "VUE";
+  ProjectType2["VUE3"] = "VUE3";
+  ProjectType2["SFC_VUE"] = "SFC_VUE";
+  ProjectType2["ANGULAR"] = "ANGULAR";
+  ProjectType2["EMBER"] = "EMBER";
+  ProjectType2["WEB_COMPONENTS"] = "WEB_COMPONENTS";
+  ProjectType2["MITHRIL"] = "MITHRIL";
+  ProjectType2["MARIONETTE"] = "MARIONETTE";
+  ProjectType2["MARKO"] = "MARKO";
+  ProjectType2["HTML"] = "HTML";
+  ProjectType2["QWIK"] = "QWIK";
+  ProjectType2["RIOT"] = "RIOT";
+  ProjectType2["PREACT"] = "PREACT";
+  ProjectType2["SVELTE"] = "SVELTE";
+  ProjectType2["SVELTEKIT"] = "SVELTEKIT";
+  ProjectType2["RAX"] = "RAX";
+  ProjectType2["AURELIA"] = "AURELIA";
+  ProjectType2["SERVER"] = "SERVER";
+  ProjectType2["NX"] = "NX";
+  ProjectType2["SOLID"] = "SOLID";
+  return ProjectType2;
+})(ProjectType || {});
+var supportedTemplates = [
+  {
+    preset: "SFC_VUE" /* SFC_VUE */,
+    dependencies: {
+      "vue-loader": (versionRange) => ltMajor(versionRange, 16),
+      vuetify: (versionRange) => ltMajor(versionRange, 3)
+    },
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.some(Boolean);
+    }
+  },
+  {
+    preset: "VUE" /* VUE */,
+    // This Vue template only works with Vue or Nuxt under v3
+    dependencies: {
+      vue: (versionRange) => ltMajor(versionRange, 3),
+      nuxt: (versionRange) => ltMajor(versionRange, 3)
+    },
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.some(Boolean);
+    }
+  },
+  {
+    preset: "VUE3" /* VUE3 */,
+    dependencies: {
+      // This Vue template works with Vue 3
+      vue: (versionRange) => versionRange === "next" || eqMajor(versionRange, 3)
+    },
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.some(Boolean);
+    }
+  },
+  {
+    preset: "EMBER" /* EMBER */,
+    dependencies: ["ember-cli"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "NEXTJS" /* NEXTJS */,
+    dependencies: {
+      next: (versionRange) => eqMajor(versionRange, 9) || gtMajor(versionRange, 9)
+    },
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "QWIK" /* QWIK */,
+    dependencies: ["@builder.io/qwik"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "REACT_PROJECT" /* REACT_PROJECT */,
+    peerDependencies: ["react"],
+    matcherFunction: ({ peerDependencies }) => {
+      return peerDependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "REACT_NATIVE" /* REACT_NATIVE */,
+    dependencies: ["react-native", "react-native-scripts"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.some(Boolean);
+    }
+  },
+  {
+    preset: "REACT_SCRIPTS" /* REACT_SCRIPTS */,
+    // For projects using a custom/forked `react-scripts` package.
+    files: ["/node_modules/.bin/react-scripts"],
+    // For standard CRA projects
+    dependencies: ["react-scripts"],
+    matcherFunction: ({ dependencies, files }) => {
+      return dependencies.every(Boolean) || files.every(Boolean);
+    }
+  },
+  {
+    preset: "ANGULAR" /* ANGULAR */,
+    dependencies: ["@angular/core"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "WEB_COMPONENTS" /* WEB_COMPONENTS */,
+    dependencies: ["lit-element", "lit-html", "lit"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.some(Boolean);
+    }
+  },
+  {
+    preset: "MITHRIL" /* MITHRIL */,
+    dependencies: ["mithril"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "MARIONETTE" /* MARIONETTE */,
+    dependencies: ["backbone.marionette"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "MARKO" /* MARKO */,
+    dependencies: ["marko"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "RIOT" /* RIOT */,
+    dependencies: ["riot"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "PREACT" /* PREACT */,
+    dependencies: ["preact"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    // TODO: This only works because it is before the SVELTE template. could be more explicit
+    preset: "SVELTEKIT" /* SVELTEKIT */,
+    dependencies: ["@sveltejs/kit"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "SVELTE" /* SVELTE */,
+    dependencies: ["svelte"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "RAX" /* RAX */,
+    dependencies: ["rax"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "AURELIA" /* AURELIA */,
+    dependencies: ["aurelia-bootstrapper"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "SOLID" /* SOLID */,
+    dependencies: ["solid-js"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  // DO NOT MOVE ANY TEMPLATES BELOW THIS LINE
+  // React is part of every Template, after Storybook is initialized once
+  {
+    preset: "WEBPACK_REACT" /* WEBPACK_REACT */,
+    dependencies: ["react", "webpack"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  },
+  {
+    preset: "REACT" /* REACT */,
+    dependencies: ["react"],
+    matcherFunction: ({ dependencies }) => {
+      return dependencies.every(Boolean);
+    }
+  }
+];
+var unsupportedTemplate = {
+  preset: "UNSUPPORTED" /* UNSUPPORTED */,
+  dependencies: {
+    // TODO(blaine): Remove when we support Nuxt 3
+    nuxt: (versionRange) => eqMajor(versionRange, 3)
+  },
+  matcherFunction: ({ dependencies }) => {
+    return dependencies.some(Boolean);
+  }
+};
+var notInstallableProjectTypes = ["UNDETECTED" /* UNDETECTED */, "UNSUPPORTED" /* UNSUPPORTED */];
+var installableProjectTypes = Object.values(ProjectType).filter((type) => !notInstallableProjectTypes.includes(type)).map((type) => type.toLowerCase());
+
+// src/versions.ts
+var versions_default = {
+  "@storybook/addon-a11y": "7.0.0-beta.61",
+  "@storybook/addon-actions": "7.0.0-beta.61",
+  "@storybook/addon-backgrounds": "7.0.0-beta.61",
+  "@storybook/addon-controls": "7.0.0-beta.61",
+  "@storybook/addon-docs": "7.0.0-beta.61",
+  "@storybook/addon-essentials": "7.0.0-beta.61",
+  "@storybook/addon-highlight": "7.0.0-beta.61",
+  "@storybook/addon-interactions": "7.0.0-beta.61",
+  "@storybook/addon-jest": "7.0.0-beta.61",
+  "@storybook/addon-links": "7.0.0-beta.61",
+  "@storybook/addon-measure": "7.0.0-beta.61",
+  "@storybook/addon-outline": "7.0.0-beta.61",
+  "@storybook/addon-storyshots": "7.0.0-beta.61",
+  "@storybook/addon-storyshots-puppeteer": "7.0.0-beta.61",
+  "@storybook/addon-storysource": "7.0.0-beta.61",
+  "@storybook/addon-toolbars": "7.0.0-beta.61",
+  "@storybook/addon-viewport": "7.0.0-beta.61",
+  "@storybook/addons": "7.0.0-beta.61",
+  "@storybook/angular": "7.0.0-beta.61",
+  "@storybook/api": "7.0.0-beta.61",
+  "@storybook/builder-manager": "7.0.0-beta.61",
+  "@storybook/builder-vite": "7.0.0-beta.61",
+  "@storybook/builder-webpack5": "7.0.0-beta.61",
+  "@storybook/channel-postmessage": "7.0.0-beta.61",
+  "@storybook/channel-websocket": "7.0.0-beta.61",
+  "@storybook/channels": "7.0.0-beta.61",
+  "@storybook/cli": "7.0.0-beta.61",
+  "@storybook/client-api": "7.0.0-beta.61",
+  "@storybook/client-logger": "7.0.0-beta.61",
+  "@storybook/codemod": "7.0.0-beta.61",
+  "@storybook/core-client": "7.0.0-beta.61",
+  "@storybook/core-common": "7.0.0-beta.61",
+  "@storybook/core-events": "7.0.0-beta.61",
+  "@storybook/core-server": "7.0.0-beta.61",
+  "@storybook/core-webpack": "7.0.0-beta.61",
+  "@storybook/csf-plugin": "7.0.0-beta.61",
+  "@storybook/csf-tools": "7.0.0-beta.61",
+  "@storybook/docs-tools": "7.0.0-beta.61",
+  "@storybook/ember": "7.0.0-beta.61",
+  "@storybook/html": "7.0.0-beta.61",
+  "@storybook/html-vite": "7.0.0-beta.61",
+  "@storybook/html-webpack5": "7.0.0-beta.61",
+  "@storybook/instrumenter": "7.0.0-beta.61",
+  "@storybook/manager-api": "7.0.0-beta.61",
+  "@storybook/nextjs": "7.0.0-beta.61",
+  "@storybook/node-logger": "7.0.0-beta.61",
+  "@storybook/postinstall": "7.0.0-beta.61",
+  "@storybook/preact": "7.0.0-beta.61",
+  "@storybook/preact-vite": "7.0.0-beta.61",
+  "@storybook/preact-webpack5": "7.0.0-beta.61",
+  "@storybook/preset-create-react-app": "7.0.0-beta.61",
+  "@storybook/preset-html-webpack": "7.0.0-beta.61",
+  "@storybook/preset-preact-webpack": "7.0.0-beta.61",
+  "@storybook/preset-react-webpack": "7.0.0-beta.61",
+  "@storybook/preset-server-webpack": "7.0.0-beta.61",
+  "@storybook/preset-svelte-webpack": "7.0.0-beta.61",
+  "@storybook/preset-vue-webpack": "7.0.0-beta.61",
+  "@storybook/preset-vue3-webpack": "7.0.0-beta.61",
+  "@storybook/preset-web-components-webpack": "7.0.0-beta.61",
+  "@storybook/preview": "7.0.0-beta.61",
+  "@storybook/preview-api": "7.0.0-beta.61",
+  "@storybook/preview-web": "7.0.0-beta.61",
+  "@storybook/react": "7.0.0-beta.61",
+  "@storybook/react-dom-shim": "7.0.0-beta.61",
+  "@storybook/react-vite": "7.0.0-beta.61",
+  "@storybook/react-webpack5": "7.0.0-beta.61",
+  "@storybook/router": "7.0.0-beta.61",
+  "@storybook/server": "7.0.0-beta.61",
+  "@storybook/server-webpack5": "7.0.0-beta.61",
+  "@storybook/source-loader": "7.0.0-beta.61",
+  "@storybook/store": "7.0.0-beta.61",
+  "@storybook/svelte": "7.0.0-beta.61",
+  "@storybook/svelte-vite": "7.0.0-beta.61",
+  "@storybook/svelte-webpack5": "7.0.0-beta.61",
+  "@storybook/sveltekit": "7.0.0-beta.61",
+  "@storybook/telemetry": "7.0.0-beta.61",
+  "@storybook/theming": "7.0.0-beta.61",
+  "@storybook/types": "7.0.0-beta.61",
+  "@storybook/vue": "7.0.0-beta.61",
+  "@storybook/vue-vite": "7.0.0-beta.61",
+  "@storybook/vue-webpack5": "7.0.0-beta.61",
+  "@storybook/vue3": "7.0.0-beta.61",
+  "@storybook/vue3-vite": "7.0.0-beta.61",
+  "@storybook/vue3-webpack5": "7.0.0-beta.61",
+  "@storybook/web-components": "7.0.0-beta.61",
+  "@storybook/web-components-vite": "7.0.0-beta.61",
+  "@storybook/web-components-webpack5": "7.0.0-beta.61",
+  sb: "7.0.0-beta.61",
+  storybook: "7.0.0-beta.61"
+};
+
+// src/dirs.ts
+function getCliDir() {
+  return dirname(__require.resolve("@storybook/cli/package.json"));
+}
+var resolveUsingBranchInstall = async (packageManager, request) => {
+  const tempDirectory = tempy.directory();
+  const name = request;
+  const version = versions_default[name] || await packageManager.latestVersion(request);
+  const url = getNpmTarballUrl(request, version, { registry: packageManager.getRegistryURL() });
+  await downloadTarball({ url, dir: tempDirectory });
+  return join(tempDirectory, "package");
+};
+async function getRendererDir(packageManager, renderer) {
+  const externalFramework = externalFrameworks.find((framework) => framework.name === renderer);
+  const frameworkPackageName = externalFramework?.renderer || externalFramework?.packageName || `@storybook/${renderer}`;
+  const packageJsonPath = `${frameworkPackageName}/package.json`;
+  const errors = [];
+  try {
+    return dirname(
+      __require.resolve(packageJsonPath, {
+        paths: [process.cwd()]
+      })
+    );
+  } catch (e) {
+    errors.push(e);
+  }
+  try {
+    return await resolveUsingBranchInstall(packageManager, frameworkPackageName);
+  } catch (e) {
+    errors.push(e);
+  }
+  throw new Error(`Cannot find ${packageJsonPath}, ${errors.map((e) => e.stack).join("\n\n")}`);
+}
+
+// src/helpers.ts
+var logger = console;
+function getBowerJson() {
+  const bowerJsonPath = path.resolve("bower.json");
+  if (!fs.existsSync(bowerJsonPath)) {
+    return false;
+  }
+  const jsonContent = fs.readFileSync(bowerJsonPath, "utf8");
+  return JSON.parse(jsonContent);
+}
+function readFileAsJson(jsonPath, allowComments) {
+  const filePath = path.resolve(jsonPath);
+  if (!fs.existsSync(filePath)) {
+    return false;
+  }
+  const fileContent = fs.readFileSync(filePath, "utf8");
+  const jsonContent = allowComments ? stripJsonComments(fileContent) : fileContent;
+  try {
+    return JSON.parse(jsonContent);
+  } catch (e) {
+    logger.error(chalk.red(`Invalid json in file: ${filePath}`));
+    throw e;
+  }
+}
+var writeFileAsJson = (jsonPath, content) => {
+  const filePath = path.resolve(jsonPath);
+  if (!fs.existsSync(filePath)) {
+    return false;
+  }
+  fs.writeFileSync(filePath, `${JSON.stringify(content, null, 2)}
+`);
+  return true;
+};
+var commandLog = (message) => {
+  process.stdout.write(chalk.cyan(" \u2022 ") + message);
+  return (errorMessage, errorInfo) => {
+    if (errorMessage) {
+      process.stdout.write(`. ${chalk.red("\u2716")}
+`);
+      logger.error(`
+     ${chalk.red(errorMessage)}`);
+      if (!errorInfo) {
+        return;
+      }
+      const newErrorInfo = errorInfo.split("\n").map((line) => `     ${chalk.dim(line)}`).join("\n");
+      logger.error(`${newErrorInfo}
+`);
+      return;
+    }
+    process.stdout.write(`. ${chalk.green("\u2713")}
+`);
+  };
+};
+function paddedLog(message) {
+  const newMessage = message.split("\n").map((line) => `    ${line}`).join("\n");
+  logger.log(newMessage);
+}
+function getChars(char, amount) {
+  let line = "";
+  for (let lc = 0; lc < amount; lc += 1) {
+    line += char;
+  }
+  return line;
+}
+function codeLog(codeLines, leftPadAmount) {
+  let maxLength = 0;
+  const newLines = codeLines.map((line) => {
+    maxLength = line.length > maxLength ? line.length : maxLength;
+    return line;
+  });
+  const finalResult = newLines.map((line) => {
+    const rightPadAmount = maxLength - line.length;
+    let newLine = line + getChars(" ", rightPadAmount);
+    newLine = getChars(" ", leftPadAmount || 2) + chalk.inverse(` ${newLine} `);
+    return newLine;
+  }).join("\n");
+  logger.log(finalResult);
+}
+async function getBabelDependencies(packageManager, packageJson) {
+  const dependenciesToAdd = [];
+  let babelLoaderVersion = "^8.0.0-0";
+  const babelCoreVersion = packageJson.dependencies["babel-core"] || packageJson.devDependencies["babel-core"];
+  if (!babelCoreVersion) {
+    if (!packageJson.dependencies["@babel/core"] && !packageJson.devDependencies["@babel/core"]) {
+      const babelCoreInstallVersion = await packageManager.getVersion("@babel/core");
+      dependenciesToAdd.push(`@babel/core@${babelCoreInstallVersion}`);
+    }
+  } else {
+    const latestCompatibleBabelVersion = await packageManager.latestVersion(
+      "babel-core",
+      babelCoreVersion
+    );
+    if (satisfies(latestCompatibleBabelVersion, "^6.0.0")) {
+      babelLoaderVersion = "^7.0.0";
+    }
+  }
+  if (!packageJson.dependencies["babel-loader"] && !packageJson.devDependencies["babel-loader"]) {
+    const babelLoaderInstallVersion = await packageManager.getVersion(
+      "babel-loader",
+      babelLoaderVersion
+    );
+    dependenciesToAdd.push(`babel-loader@${babelLoaderInstallVersion}`);
+  }
+  return dependenciesToAdd;
+}
+function copyTemplate(templateRoot, destination = ".") {
+  const templateDir = path.resolve(templateRoot, `template-csf/`);
+  if (!fs.existsSync(templateDir)) {
+    throw new Error(`Couldn't find template dir`);
+  }
+  fse.copySync(templateDir, destination, { overwrite: true });
+}
+async function copyTemplateFiles({
+  packageManager,
+  renderer,
+  language,
+  destination,
+  includeCommonAssets = true
+}) {
+  const languageFolderMapping = {
+    ["javascript" /* JAVASCRIPT */]: "js",
+    ["typescript-3-8" /* TYPESCRIPT_3_8 */]: "ts-3-8",
+    ["typescript-4-9" /* TYPESCRIPT_4_9 */]: "ts-4-9"
+  };
+  const templatePath = async () => {
+    const baseDir = await getRendererDir(packageManager, renderer);
+    const assetsDir = join2(baseDir, "template/cli");
+    const assetsLanguage = join2(assetsDir, languageFolderMapping[language]);
+    const assetsJS = join2(assetsDir, languageFolderMapping["javascript" /* JAVASCRIPT */]);
+    const assetsTS38 = join2(assetsDir, languageFolderMapping["typescript-3-8" /* TYPESCRIPT_3_8 */]);
+    if (await fse.pathExists(assetsLanguage)) {
+      return assetsLanguage;
+    }
+    if (language === "typescript-4-9" /* TYPESCRIPT_4_9 */ && await fse.pathExists(assetsTS38)) {
+      return assetsTS38;
+    }
+    if (await fse.pathExists(assetsJS)) {
+      return assetsJS;
+    }
+    if (await fse.pathExists(assetsDir)) {
+      return assetsDir;
+    }
+    throw new Error(`Unsupported renderer: ${renderer} (${baseDir})`);
+  };
+  const targetPath = async () => {
+    if (await fse.pathExists("./src")) {
+      return "./src/stories";
+    }
+    return "./stories";
+  };
+  const destinationPath = destination ?? await targetPath();
+  if (includeCommonAssets) {
+    await fse.copy(join2(getCliDir(), "rendererAssets/common"), destinationPath, {
+      overwrite: true
+    });
+  }
+  await fse.copy(await templatePath(), destinationPath, { overwrite: true });
+}
+function getStorybookVersionSpecifier(packageJson) {
+  const allDeps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+  const storybookPackage = Object.keys(allDeps).find(
+    (name) => {
+      return versions_default[name];
+    }
+  );
+  if (!storybookPackage) {
+    throw new Error(`Couldn't find any official storybook packages in package.json`);
+  }
+  return allDeps[storybookPackage];
+}
+
+// src/js-package-manager/JsPackageManager.ts
+var logger2 = console;
+function getPackageDetails(pkg) {
+  const idx = pkg.lastIndexOf("@");
+  if (idx <= 0) {
+    return [pkg, void 0];
+  }
+  const packageName = pkg.slice(0, idx);
+  const packageVersion = pkg.slice(idx + 1);
+  return [packageName, packageVersion];
+}
+var JsPackageManager = class {
+  // NOTE: for some reason yarn prefers the npm registry in
+  // local development, so always use npm
+  setRegistryURL(url) {
+    if (url) {
+      this.executeCommand("npm", ["config", "set", "registry", url]);
+    } else {
+      this.executeCommand("npm", ["config", "delete", "registry"]);
+    }
+  }
+  getRegistryURL() {
+    const url = this.executeCommand("npm", ["config", "get", "registry"]).trim();
+    return url === "undefined" ? void 0 : url;
+  }
+  constructor(options) {
+    this.cwd = options?.cwd;
+  }
+  /**
+   * Install dependencies listed in `package.json`
+   */
+  installDependencies() {
+    let done = commandLog("Preparing to install dependencies");
+    done();
+    logger2.log();
+    logger2.log();
+    done = commandLog("Installing dependencies");
+    try {
+      this.runInstall();
+    } catch (e) {
+      done("An error occurred while installing dependencies.");
+      process.exit(1);
+    }
+    done();
+  }
+  packageJsonPath() {
+    return this.cwd ? path2.resolve(this.cwd, "package.json") : path2.resolve("package.json");
+  }
+  readPackageJson() {
+    const packageJsonPath = this.packageJsonPath();
+    if (!fs2.existsSync(packageJsonPath)) {
+      throw new Error(`Could not read package.json file at ${packageJsonPath}`);
+    }
+    const jsonContent = fs2.readFileSync(packageJsonPath, "utf8");
+    return JSON.parse(jsonContent);
+  }
+  writePackageJson(packageJson) {
+    const packageJsonToWrite = { ...packageJson };
+    if (packageJsonToWrite.dependencies && Object.keys(packageJsonToWrite.dependencies).length === 0) {
+      delete packageJsonToWrite.dependencies;
+    }
+    if (packageJsonToWrite.devDependencies && Object.keys(packageJsonToWrite.devDependencies).length === 0) {
+      delete packageJsonToWrite.devDependencies;
+    }
+    if (packageJsonToWrite.dependencies && Object.keys(packageJsonToWrite.peerDependencies).length === 0) {
+      delete packageJsonToWrite.peerDependencies;
+    }
+    const content = `${JSON.stringify(packageJsonToWrite, null, 2)}
+`;
+    fs2.writeFileSync(this.packageJsonPath(), content, "utf8");
+  }
+  /**
+   * Read the `package.json` file available in the directory the command was call from
+   * If there is no `package.json` it will create one.
+   */
+  retrievePackageJson() {
+    let packageJson;
+    try {
+      packageJson = this.readPackageJson();
+    } catch (err) {
+      this.initPackageJson();
+      packageJson = this.readPackageJson();
+    }
+    return {
+      ...packageJson,
+      dependencies: { ...packageJson.dependencies },
+      devDependencies: { ...packageJson.devDependencies },
+      peerDependencies: { ...packageJson.peerDependencies }
+    };
+  }
+  getAllDependencies() {
+    const { dependencies, devDependencies, peerDependencies } = this.retrievePackageJson();
+    return {
+      ...dependencies,
+      ...devDependencies,
+      ...peerDependencies
+    };
+  }
+  /**
+   * Add dependencies to a project using `yarn add` or `npm install`.
+   *
+   * @param {Object} options contains `skipInstall`, `packageJson` and `installAsDevDependencies` which we use to determine how we install packages.
+   * @param {Array} dependencies contains a list of packages to add.
+   * @example
+   * addDependencies(options, [
+   *   `@storybook/react@${storybookVersion}`,
+   *   `@storybook/addon-actions@${actionsVersion}`,
+   *   `@storybook/addon-links@${linksVersion}`,
+   *   `@storybook/preview-api@${addonsVersion}`,
+   * ]);
+   */
+  addDependencies(options, dependencies) {
+    const { skipInstall } = options;
+    if (skipInstall) {
+      const { packageJson } = options;
+      const dependenciesMap = dependencies.reduce((acc, dep) => {
+        const [packageName, packageVersion] = getPackageDetails(dep);
+        return { ...acc, [packageName]: packageVersion };
+      }, {});
+      if (options.installAsDevDependencies) {
+        packageJson.devDependencies = {
+          ...packageJson.devDependencies,
+          ...dependenciesMap
+        };
+      } else {
+        packageJson.dependencies = {
+          ...packageJson.dependencies,
+          ...dependenciesMap
+        };
+      }
+      this.writePackageJson(packageJson);
+    } else {
+      try {
+        this.runAddDeps(dependencies, options.installAsDevDependencies);
+      } catch (e) {
+        logger2.error("An error occurred while installing dependencies.");
+        logger2.log(e.message);
+        process.exit(1);
+      }
+    }
+  }
+  /**
+   * Remove dependencies from a project using `yarn remove` or `npm uninstall`.
+   *
+   * @param {Object} options contains `skipInstall`, `packageJson` and `installAsDevDependencies` which we use to determine how we install packages.
+   * @param {Array} dependencies contains a list of packages to remove.
+   * @example
+   * removeDependencies(options, [
+   *   `@storybook/react`,
+   *   `@storybook/addon-actions`,
+   * ]);
+   */
+  removeDependencies(options, dependencies) {
+    const { skipInstall } = options;
+    if (skipInstall) {
+      const { packageJson } = options;
+      dependencies.forEach((dep) => {
+        if (packageJson.devDependencies) {
+          delete packageJson.devDependencies[dep];
+        }
+        if (packageJson.dependencies) {
+          delete packageJson.dependencies[dep];
+        }
+      });
+      this.writePackageJson(packageJson);
+    } else {
+      try {
+        this.runRemoveDeps(dependencies);
+      } catch (e) {
+        logger2.error("An error occurred while removing dependencies.");
+        logger2.log(e.message);
+        process.exit(1);
+      }
+    }
+  }
+  /**
+   * Return an array of strings matching following format: `<package_name>@<package_latest_version>`
+   *
+   * @param packages
+   */
+  getVersionedPackages(packages) {
+    return Promise.all(
+      packages.map(async (pkg) => {
+        const [packageName, packageVersion] = getPackageDetails(pkg);
+        return `${packageName}@${await this.getVersion(packageName, packageVersion)}`;
+      })
+    );
+  }
+  /**
+   * Return an array of string standing for the latest version of the input packages.
+   * To be able to identify which version goes with which package the order of the input array is keep.
+   *
+   * @param packageNames
+   */
+  getVersions(...packageNames) {
+    return Promise.all(
+      packageNames.map((packageName) => {
+        return this.getVersion(packageName);
+      })
+    );
+  }
+  /**
+   * Return the latest version of the input package available on npmjs registry.
+   * If constraint are provided it return the latest version matching the constraints.
+   *
+   * For `@storybook/*` packages the latest version is retrieved from `cli/src/versions.json` file directly
+   *
+   * @param packageName The name of the package
+   * @param constraint A valid semver constraint, example: '1.x || >=2.5.0 || 5.0.0 - 7.2.3'
+   */
+  async getVersion(packageName, constraint) {
+    let current;
+    if (/(@storybook|^sb$|^storybook$)/.test(packageName)) {
+      current = versions_default[packageName];
+    }
+    let latest;
+    try {
+      latest = await this.latestVersion(packageName, constraint);
+    } catch (e) {
+      if (current) {
+        logger2.warn(`
+     ${chalk2.yellow(e.message)}`);
+        return current;
+      }
+      logger2.error(`
+     ${chalk2.red(e.message)}`);
+      process.exit(1);
+    }
+    const versionToUse = current && (!constraint || satisfies2(current, constraint)) && gt(current, latest) ? current : latest;
+    return `^${versionToUse}`;
+  }
+  /**
+   * Get the latest version of the package available on npmjs.com.
+   * If constraint is set then it returns a version satisfying it, otherwise the latest version available is returned.
+   *
+   * @param packageName Name of the package
+   * @param constraint Version range to use to constraint the returned version
+   */
+  async latestVersion(packageName, constraint) {
+    if (!constraint) {
+      return this.runGetVersions(packageName, false);
+    }
+    const versions = await this.runGetVersions(packageName, true);
+    return versions.reverse().find((version) => satisfies2(version, constraint));
+  }
+  addStorybookCommandInScripts(options) {
+    const sbPort = options?.port ?? 6006;
+    const storybookCmd = `storybook dev -p ${sbPort}`;
+    const buildStorybookCmd = `storybook build`;
+    const preCommand = options?.preCommand ? this.getRunCommand(options.preCommand) : void 0;
+    this.addScripts({
+      storybook: [preCommand, storybookCmd].filter(Boolean).join(" && "),
+      "build-storybook": [preCommand, buildStorybookCmd].filter(Boolean).join(" && ")
+    });
+  }
+  addESLintConfig() {
+    const packageJson = this.retrievePackageJson();
+    this.writePackageJson({
+      ...packageJson,
+      eslintConfig: {
+        ...packageJson.eslintConfig,
+        overrides: [
+          ...packageJson.eslintConfig?.overrides || [],
+          {
+            files: ["**/*.stories.*"],
+            rules: {
+              "import/no-anonymous-default-export": "off"
+            }
+          }
+        ]
+      }
+    });
+  }
+  addScripts(scripts) {
+    const packageJson = this.retrievePackageJson();
+    this.writePackageJson({
+      ...packageJson,
+      scripts: {
+        ...packageJson.scripts,
+        ...scripts
+      }
+    });
+  }
+  addPackageResolutions(versions) {
+    const packageJson = this.retrievePackageJson();
+    const resolutions = this.getResolutions(packageJson, versions);
+    this.writePackageJson({ ...packageJson, ...resolutions });
+  }
+  executeCommand(command, args, stdio, cwd) {
+    const commandResult = spawnSync(command, args, {
+      cwd: cwd ?? this.cwd,
+      stdio: stdio ?? "pipe",
+      encoding: "utf-8",
+      shell: true
+    });
+    if (commandResult.status !== 0) {
+      throw new Error(commandResult.stderr ?? "");
+    }
+    return commandResult.stdout ?? "";
+  }
+};
+
+// src/js-package-manager/JsPackageManagerFactory.ts
+import path3 from "path";
+import { sync as spawnSync2 } from "cross-spawn";
+import { sync as findUpSync } from "find-up";
+
+// src/js-package-manager/NPMProxy.ts
+var NPMProxy = class extends JsPackageManager {
+  constructor() {
+    super(...arguments);
+    this.type = "npm";
+  }
+  initPackageJson() {
+    return this.executeCommand("npm", ["init", "-y"]);
+  }
+  getRunStorybookCommand() {
+    return "npm run storybook";
+  }
+  getRunCommand(command) {
+    return `npm run ${command}`;
+  }
+  getNpmVersion() {
+    return this.executeCommand("npm", ["--version"]);
+  }
+  getInstallArgs() {
+    if (!this.installArgs) {
+      this.installArgs = [];
+    }
+    return this.installArgs;
+  }
+  runPackageCommand(command, args, cwd) {
+    return this.executeCommand(`npm`, ["exec", "--", command, ...args], void 0, cwd);
+  }
+  getResolutions(packageJson, versions) {
+    return {
+      overrides: {
+        ...packageJson.overrides,
+        ...versions
+      }
+    };
+  }
+  runInstall() {
+    this.executeCommand("npm", ["install", ...this.getInstallArgs()], "inherit");
+  }
+  runAddDeps(dependencies, installAsDevDependencies) {
+    let args = [...dependencies];
+    if (installAsDevDependencies) {
+      args = ["-D", ...args];
+    }
+    this.executeCommand("npm", ["install", ...this.getInstallArgs(), ...args], "inherit");
+  }
+  runRemoveDeps(dependencies) {
+    const args = [...dependencies];
+    this.executeCommand("npm", ["uninstall", ...this.getInstallArgs(), ...args], "inherit");
+  }
+  runGetVersions(packageName, fetchAllVersions) {
+    const args = [fetchAllVersions ? "versions" : "version", "--json"];
+    const commandResult = this.executeCommand("npm", ["info", packageName, ...args]);
+    try {
+      const parsedOutput = JSON.parse(commandResult);
+      if (parsedOutput.error) {
+        throw new Error(parsedOutput.error.summary);
+      } else {
+        return parsedOutput;
+      }
+    } catch (e) {
+      throw new Error(`Unable to find versions of ${packageName} using npm`);
+    }
+  }
+};
+
+// src/js-package-manager/PNPMProxy.ts
+import { pathExistsSync } from "fs-extra";
+var PNPMProxy = class extends JsPackageManager {
+  constructor() {
+    super(...arguments);
+    this.type = "pnpm";
+  }
+  detectWorkspaceRoot() {
+    const CWD = process.cwd();
+    const pnpmWorkspaceYaml = `${CWD}/pnpm-workspace.yaml`;
+    return pathExistsSync(pnpmWorkspaceYaml);
+  }
+  initPackageJson() {
+    return this.executeCommand("pnpm", ["init", "-y"]);
+  }
+  getRunStorybookCommand() {
+    return "pnpm run storybook";
+  }
+  getRunCommand(command) {
+    return `pnpm run ${command}`;
+  }
+  getPnpmVersion() {
+    return this.executeCommand("pnpm", ["--version"]);
+  }
+  getInstallArgs() {
+    if (!this.installArgs) {
+      this.installArgs = [];
+      if (this.detectWorkspaceRoot()) {
+        this.installArgs.push("-w");
+      }
+    }
+    return this.installArgs;
+  }
+  runPackageCommand(command, args, cwd) {
+    return this.executeCommand(`pnpm`, ["exec", command, ...args], void 0, cwd);
+  }
+  getResolutions(packageJson, versions) {
+    return {
+      overrides: {
+        ...packageJson.overrides,
+        ...versions
+      }
+    };
+  }
+  runInstall() {
+    this.executeCommand("pnpm", ["install", ...this.getInstallArgs()], "inherit");
+  }
+  runAddDeps(dependencies, installAsDevDependencies) {
+    let args = [...dependencies];
+    if (installAsDevDependencies) {
+      args = ["-D", ...args];
+    }
+    this.executeCommand("pnpm", ["add", ...args, ...this.getInstallArgs()], "inherit");
+  }
+  runRemoveDeps(dependencies) {
+    const args = [...dependencies];
+    this.executeCommand("pnpm", ["remove", ...args, ...this.getInstallArgs()], "inherit");
+  }
+  runGetVersions(packageName, fetchAllVersions) {
+    const args = [fetchAllVersions ? "versions" : "version", "--json"];
+    const commandResult = this.executeCommand("pnpm", ["info", packageName, ...args]);
+    try {
+      const parsedOutput = JSON.parse(commandResult);
+      if (parsedOutput.error) {
+        throw new Error(parsedOutput.error.summary);
+      } else {
+        return parsedOutput;
+      }
+    } catch (e) {
+      throw new Error(`Unable to find versions of ${packageName} using pnpm`);
+    }
+  }
+};
+
+// src/js-package-manager/Yarn2Proxy.ts
+var Yarn2Proxy = class extends JsPackageManager {
+  constructor() {
+    super(...arguments);
+    this.type = "yarn2";
+  }
+  getInstallArgs() {
+    if (!this.installArgs) {
+      this.installArgs = [];
+    }
+    return this.installArgs;
+  }
+  initPackageJson() {
+    return this.executeCommand("yarn", ["init"]);
+  }
+  getRunStorybookCommand() {
+    return "yarn storybook";
+  }
+  getRunCommand(command) {
+    return `yarn ${command}`;
+  }
+  runPackageCommand(command, args, cwd) {
+    return this.executeCommand(`yarn`, [command, ...args], void 0, cwd);
+  }
+  getResolutions(packageJson, versions) {
+    return {
+      resolutions: {
+        ...packageJson.resolutions,
+        ...versions
+      }
+    };
+  }
+  runInstall() {
+    this.executeCommand("yarn", ["install", ...this.getInstallArgs()], "inherit");
+  }
+  runAddDeps(dependencies, installAsDevDependencies) {
+    let args = [...dependencies];
+    if (installAsDevDependencies) {
+      args = ["-D", ...args];
+    }
+    this.executeCommand("yarn", ["add", ...this.getInstallArgs(), ...args], "inherit");
+  }
+  runRemoveDeps(dependencies) {
+    const args = [...dependencies];
+    this.executeCommand("yarn", ["remove", ...this.getInstallArgs(), ...args], "inherit");
+  }
+  runGetVersions(packageName, fetchAllVersions) {
+    const field = fetchAllVersions ? "versions" : "version";
+    const args = ["--fields", field, "--json"];
+    const commandResult = this.executeCommand("yarn", ["npm", "info", packageName, ...args]);
+    try {
+      const parsedOutput = JSON.parse(commandResult);
+      return parsedOutput[field];
+    } catch (e) {
+      throw new Error(`Unable to find versions of ${packageName} using yarn 2`);
+    }
+  }
+};
+
+// src/js-package-manager/Yarn1Proxy.ts
+var Yarn1Proxy = class extends JsPackageManager {
+  constructor() {
+    super(...arguments);
+    this.type = "yarn1";
+  }
+  getInstallArgs() {
+    if (!this.installArgs) {
+      this.installArgs = ["--ignore-workspace-root-check"];
+    }
+    return this.installArgs;
+  }
+  initPackageJson() {
+    return this.executeCommand("yarn", ["init", "-y"]);
+  }
+  getRunStorybookCommand() {
+    return "yarn storybook";
+  }
+  getRunCommand(command) {
+    return `yarn ${command}`;
+  }
+  runPackageCommand(command, args, cwd) {
+    return this.executeCommand(`yarn`, [command, ...args], void 0, cwd);
+  }
+  getResolutions(packageJson, versions) {
+    return {
+      resolutions: {
+        ...packageJson.resolutions,
+        ...versions
+      }
+    };
+  }
+  runInstall() {
+    this.executeCommand("yarn", ["install", ...this.getInstallArgs()], "inherit");
+  }
+  runAddDeps(dependencies, installAsDevDependencies) {
+    let args = [...dependencies];
+    if (installAsDevDependencies) {
+      args = ["-D", ...args];
+    }
+    this.executeCommand("yarn", ["add", ...this.getInstallArgs(), ...args], "inherit");
+  }
+  runRemoveDeps(dependencies) {
+    const args = [...dependencies];
+    this.executeCommand("yarn", ["remove", ...this.getInstallArgs(), ...args], "inherit");
+  }
+  runGetVersions(packageName, fetchAllVersions) {
+    const args = [fetchAllVersions ? "versions" : "version", "--json"];
+    const commandResult = this.executeCommand("yarn", ["info", packageName, ...args]);
+    try {
+      const parsedOutput = JSON.parse(commandResult);
+      if (parsedOutput.type === "inspect") {
+        return parsedOutput.data;
+      }
+      throw new Error(`Unable to find versions of ${packageName} using yarn`);
+    } catch (e) {
+      throw new Error(`Unable to find versions of ${packageName} using yarn`);
+    }
+  }
+};
+
+// src/js-package-manager/JsPackageManagerFactory.ts
+var NPM_LOCKFILE = "package-lock.json";
+var PNPM_LOCKFILE = "pnpm-lock.yaml";
+var YARN_LOCKFILE = "yarn.lock";
+var JsPackageManagerFactory = class {
+  static getPackageManager({ force } = {}, cwd) {
+    if (force === "npm") {
+      return new NPMProxy({ cwd });
+    }
+    if (force === "pnpm") {
+      return new PNPMProxy({ cwd });
+    }
+    if (force === "yarn1") {
+      return new Yarn1Proxy({ cwd });
+    }
+    if (force === "yarn2") {
+      return new Yarn2Proxy({ cwd });
+    }
+    const yarnVersion = getYarnVersion(cwd);
+    const closestLockfilePath = findUpSync([YARN_LOCKFILE, PNPM_LOCKFILE, NPM_LOCKFILE], {
+      cwd
+    });
+    const closestLockfile = closestLockfilePath && path3.basename(closestLockfilePath);
+    const hasNPMCommand = hasNPM(cwd);
+    const hasPNPMCommand = hasPNPM(cwd);
+    if (yarnVersion && (closestLockfile === YARN_LOCKFILE || !hasNPMCommand && !hasPNPMCommand)) {
+      return yarnVersion === 1 ? new Yarn1Proxy({ cwd }) : new Yarn2Proxy({ cwd });
+    }
+    if (hasPNPMCommand && closestLockfile === PNPM_LOCKFILE) {
+      return new PNPMProxy({ cwd });
+    }
+    if (hasNPMCommand) {
+      return new NPMProxy({ cwd });
+    }
+    throw new Error("Unable to find a usable package manager within NPM, PNPM, Yarn and Yarn 2");
+  }
+};
+function hasNPM(cwd) {
+  const npmVersionCommand = spawnSync2("npm", ["--version"], { cwd, shell: true });
+  return npmVersionCommand.status === 0;
+}
+function hasPNPM(cwd) {
+  const pnpmVersionCommand = spawnSync2("pnpm", ["--version"], { cwd, shell: true });
+  return pnpmVersionCommand.status === 0;
+}
+function getYarnVersion(cwd) {
+  const yarnVersionCommand = spawnSync2("yarn", ["--version"], { cwd, shell: true });
+  if (yarnVersionCommand.status !== 0) {
+    return void 0;
+  }
+  const yarnVersion = yarnVersionCommand.output.toString().replace(/,/g, "").replace(/"/g, "");
+  return /^1\.+/.test(yarnVersion) ? 1 : 2;
+}
+
+export {
+  __require,
+  externalFrameworks,
+  SUPPORTED_RENDERERS,
+  supportedTemplates,
+  unsupportedTemplate,
+  installableProjectTypes,
+  versions_default,
+  getCliDir,
+  getBowerJson,
+  readFileAsJson,
+  writeFileAsJson,
+  commandLog,
+  paddedLog,
+  codeLog,
+  getBabelDependencies,
+  copyTemplate,
+  copyTemplateFiles,
+  getStorybookVersionSpecifier,
+  useNpmWarning,
+  getPackageDetails,
+  JsPackageManager,
+  JsPackageManagerFactory
+};