@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

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

@@ -0,0 +1,989 @@
+import CJS_COMPAT_NODE_URL_ro17f80mg6k from 'node:url';
+import CJS_COMPAT_NODE_PATH_ro17f80mg6k from 'node:path';
+import CJS_COMPAT_NODE_MODULE_ro17f80mg6k from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_ro17f80mg6k.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_ro17f80mg6k.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_ro17f80mg6k.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  RN_STORYBOOK_DIR
+} from "./chunk-SWO5CDYU.js";
+import {
+  createModuleResolver
+} from "./chunk-YZFWBA5L.js";
+import {
+  detectIndent
+} from "./chunk-RZMQ7S3L.js";
+import {
+  findFilesUp,
+  getProjectRoot
+} from "./chunk-SLWQNBGO.js";
+import {
+  up2 as up
+} from "./chunk-JDXXX6LB.js";
+import {
+  invariant
+} from "./chunk-34EO2PUT.js";
+import {
+  importModule
+} from "./chunk-F3ZFKBHY.js";
+import {
+  storybookConfigExtensions
+} from "./chunk-TNJIXE37.js";
+import {
+  require_picocolors
+} from "./chunk-2BUPBPFB.js";
+import {
+  slash
+} from "./chunk-DC7DKR5K.js";
+import {
+  glob,
+  globSync
+} from "./chunk-ZMAMXQKP.js";
+import {
+  __toESM
+} from "./chunk-CXRU72ET.js";
+
+// src/common/versions.ts
+var versions_default = { "@aussieljk/forkbook": "0.0.1-2" };
+
+// src/common/utils/HandledError.ts
+var HandledError = class extends Error {
+  constructor(error) {
+    super(String(error));
+    this.handled = !0;
+    typeof error != "string" && (this.cause = error);
+  }
+};
+
+// src/common/utils/get-pkg-pr-new-package-specifier.ts
+var PKG_PR_NEW_STORYBOOK_SPECIFIER_RE = /^(https?:\/\/[^/\s]*pkg\.pr\.new\/(?:[^@\s/]+\/[^@\s/]+\/)?)(?:create-storybook|storybook|@storybook\/[^@\s]+)(@[^\s]+)$/, isPkgPrNewVersionSpecifier = (storybookVersionSpecifier) => !!storybookVersionSpecifier?.match(PKG_PR_NEW_STORYBOOK_SPECIFIER_RE), getPkgPrNewPackageSpecifier = (packageName, storybookVersionSpecifier) => {
+  if (!storybookVersionSpecifier)
+    return;
+  let match = storybookVersionSpecifier.match(PKG_PR_NEW_STORYBOOK_SPECIFIER_RE);
+  if (!match)
+    return;
+  let [, prefix, suffix] = match;
+  return `${prefix}${packageName}${suffix}`;
+};
+
+// src/common/js-package-manager/util.ts
+import { gt, prerelease, valid } from "semver";
+var FORKBOOK_PACKAGE_PATTERNS = [
+  "@aussieljk/forkbook",
+  "@storybook/*",
+  "eslint-plugin-storybook"
+], escapePatternForRegex = (pattern) => pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), packagePatternToRegex = (pattern) => new RegExp(`^${escapePatternForRegex(pattern).replace(/\\\*/g, ".*")}$`), hasStorybookMinimumAgeExclusions = (configuredPatterns) => FORKBOOK_PACKAGE_PATTERNS.every(
+  (storybookPattern) => configuredPatterns.some(
+    (configuredPattern) => packagePatternToRegex(configuredPattern).test(storybookPattern)
+  )
+), parsePackageData = (packageName = "") => {
+  let [first, second, third] = packageName.replace(/[└─├]+/g, "").trim().split("@"), version = (third || second).replace("npm:", "");
+  return { name: third ? `@${second}` : first, value: { version, location: "" } };
+}, parsePositiveIntegerConfigValue = (value) => {
+  let normalizedValue = value?.trim() ?? "";
+  if (!normalizedValue || normalizedValue === "undefined" || normalizedValue === "null" || normalizedValue === "false")
+    return null;
+  let parsedValue = Number.parseInt(normalizedValue, 10);
+  return !Number.isFinite(parsedValue) || parsedValue <= 0 ? null : parsedValue;
+}, parseReleaseTime = (value) => {
+  if (typeof value != "string" || value.length === 0)
+    return null;
+  let releaseTime = new Date(value);
+  return Number.isNaN(releaseTime.getTime()) ? null : releaseTime;
+}, parsePackageTimeMap = (value) => {
+  if (Array.isArray(value) && value.length === 1 && (value = value[0]), !value || typeof value != "object" || Array.isArray(value))
+    return null;
+  let timeMap = {};
+  for (let [version, releaseTime] of Object.entries(value))
+    typeof releaseTime == "string" && releaseTime.length > 0 && (timeMap[version] = releaseTime);
+  return timeMap;
+}, getAgeInMinutes = (publishedAt, now = /* @__PURE__ */ new Date()) => Math.floor((now.getTime() - publishedAt.getTime()) / 6e4), getLatestStableVersionAdheringToMinimumAgeGate = (timeMap, minimumAgeGateMinutes, now = /* @__PURE__ */ new Date()) => {
+  let cutoff = now.getTime() - minimumAgeGateMinutes * 6e4, latestStableVersion = null;
+  for (let [version, releaseTime] of Object.entries(timeMap)) {
+    if (!valid(version) || prerelease(version))
+      continue;
+    let publishedAt = parseReleaseTime(releaseTime);
+    !publishedAt || publishedAt.getTime() > cutoff || (!latestStableVersion || gt(version, latestStableVersion)) && (latestStableVersion = version);
+  }
+  return latestStableVersion;
+};
+function getVitestStorybookRunCommand(packageManager, file) {
+  let args = ["vitest", "--project", "storybook", "run"];
+  return file && args.push(file), packageManager.getPackageCommand(args);
+}
+function getMswInitCommand(packageManager) {
+  return packageManager.getPackageCommand(["msw", "init", "./public", "--save"]);
+}
+var FORKBOOK_RERUN_INSTRUCTION = "Please rerun Forkbook creation with:", getStorybookRerunCommand = (compatibleVersion) => compatibleVersion ? `npx @aussieljk/forkbook@${compatibleVersion} init` : "npx @aussieljk/forkbook@<compatible-version> init", getErrorLogs = (error) => {
+  if (typeof error == "string")
+    return error;
+  if (error && typeof error == "object") {
+    let structuredError = error, structuredLogs = [
+      structuredError.shortMessage,
+      structuredError.originalMessage,
+      structuredError.stderr,
+      structuredError.stdout,
+      structuredError.message
+    ].filter((entry) => typeof entry == "string" && entry.length > 0);
+    if (structuredLogs.length > 0)
+      return structuredLogs.join(`
+`);
+  }
+  return String(error);
+}, INSTALL_ERROR_TAIL_LINES = 15, getInstallErrorTail = (error, lines = INSTALL_ERROR_TAIL_LINES) => {
+  let output = getErrorLogs(error).trimEnd();
+  return output ? output.split(`
+`).slice(-lines).join(`
+`).trim() : "";
+};
+
+// src/common/js-package-manager/vite-plus-versions.ts
+import { logger } from "@aussieljk/forkbook/internal/node-logger";
+var cachedVersions;
+async function getVitePlusVersions() {
+  if (cachedVersions !== void 0)
+    return cachedVersions;
+  try {
+    let mod = await import("vite-plus/versions"), versions = mod.versions ?? mod;
+    if (versions && typeof versions.vite == "string")
+      return logger.debug(`Detected vite-plus: vite=${versions.vite}, vitest=${versions.vitest ?? "N/A"}`), cachedVersions = versions, versions;
+  } catch {
+  }
+  return cachedVersions = null, null;
+}
+function clearVitePlusCache() {
+  cachedVersions = void 0;
+}
+
+// src/common/js-package-manager/JsPackageManager.ts
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, normalize, resolve } from "node:path";
+import { logger as logger2, prompt } from "@aussieljk/forkbook/internal/node-logger";
+var import_picocolors = __toESM(require_picocolors(), 1);
+import { coerce, gt as gt2, satisfies, validRange } from "semver";
+var PackageManagerName = /* @__PURE__ */ ((PackageManagerName2) => (PackageManagerName2.NPM = "npm", PackageManagerName2.YARN1 = "yarn1", PackageManagerName2.YARN2 = "yarn2", PackageManagerName2.PNPM = "pnpm", PackageManagerName2.BUN = "bun", PackageManagerName2))(PackageManagerName || {}), indentSymbol = /* @__PURE__ */ Symbol("indent"), PACKAGE_MANAGER_LABEL = {
+  npm: "npm",
+  yarn1: "Yarn Classic (v1)",
+  yarn2: "Yarn Berry",
+  pnpm: "pnpm",
+  bun: "Bun"
+};
+function isValidPackageManagerName(name) {
+  return Object.hasOwn(PACKAGE_MANAGER_LABEL, name);
+}
+function getPrettyPackageManagerName(packageManager) {
+  return packageManager ? isValidPackageManagerName(packageManager) ? PACKAGE_MANAGER_LABEL[packageManager] : packageManager : "unknown package manager";
+}
+function getPackageDetails(pkg) {
+  let isScopedPackage = pkg.startsWith("@"), scopeSeparatorIndex = isScopedPackage ? pkg.indexOf("/") : -1, versionSeparatorIndex = isScopedPackage ? scopeSeparatorIndex === -1 ? -1 : pkg.indexOf("@", scopeSeparatorIndex + 1) : pkg.indexOf("@");
+  if (versionSeparatorIndex <= 0)
+    return [pkg, void 0];
+  let packageName = pkg.slice(0, versionSeparatorIndex), packageVersion = pkg.slice(versionSeparatorIndex + 1);
+  return [packageName, packageVersion];
+}
+var JsPackageManager = class _JsPackageManager {
+  static {
+    /** Cache for latest version results to avoid repeated network calls. */
+    this.latestVersionCache = /* @__PURE__ */ new Map();
+  }
+  static {
+    /** Cache for installed version results to avoid repeated file system calls. */
+    this.installedVersionCache = /* @__PURE__ */ new Map();
+  }
+  static {
+    /** Cache for package.json files to avoid repeated file system calls. */
+    this.packageJsonCache = /* @__PURE__ */ new Map();
+  }
+  constructor(options) {
+    this.cwd = options?.cwd || process.cwd(), this.instanceDir = options?.configDir ? isAbsolute(options?.configDir) ? dirname(options?.configDir) : dirname(join(this.cwd, options?.configDir)) : this.cwd, this.packageJsonPaths = _JsPackageManager.listAllPackageJsonPaths(
+      this.instanceDir,
+      options?.storiesPaths
+    ), this.primaryPackageJson = this.#getPrimaryPackageJson();
+  }
+  isStorybookInMonorepo() {
+    let turboJsonPath = up("turbo.json", { last: getProjectRoot() }), rushJsonPath = up("rush.json", { last: getProjectRoot() }), nxJsonPath = up("nx.json", { last: getProjectRoot() });
+    if (turboJsonPath || rushJsonPath || nxJsonPath)
+      return !0;
+    let packageJsonPaths = findFilesUp(["package.json"]);
+    if (packageJsonPaths.length === 0)
+      return !1;
+    for (let packageJsonPath of packageJsonPaths) {
+      let packageJsonFile = readFileSync(packageJsonPath, "utf8");
+      if (JSON.parse(packageJsonFile).workspaces)
+        return !0;
+    }
+    return !1;
+  }
+  async installDependencies(options) {
+    try {
+      await prompt.executeTaskWithSpinner(() => this.runInstall(options), {
+        id: "install-dependencies",
+        intro: "Installing dependencies...",
+        error: "Installation of dependencies failed!",
+        success: "Dependencies installed"
+      });
+    } catch (error) {
+      let tail = getInstallErrorTail(error);
+      throw tail && (logger2.error(tail), error instanceof Error && !error.message.includes(tail) && (error.message = `${error.message}
+
+${tail}`)), error;
+    }
+    this.clearInstalledVersionCache();
+  }
+  async precheckStorybookPackageInstall(options) {
+  }
+  async dedupeDependencies(options) {
+    await prompt.executeTask(
+      (_signal) => this.runInternalCommand("dedupe", [...options?.force ? ["--force"] : []], this.cwd),
+      {
+        intro: "Deduplicating dependencies...",
+        error: "An error occurred while deduplicating dependencies.",
+        success: "Dependencies deduplicated"
+      }
+    ), this.clearInstalledVersionCache();
+  }
+  /** Read the `package.json` file available in the provided directory */
+  static getPackageJson(packageJsonPath) {
+    let absolutePath = normalize(resolve(packageJsonPath)), cached = _JsPackageManager.packageJsonCache.get(absolutePath);
+    if (cached)
+      return logger2.debug(`Using cached package.json for ${absolutePath}...`), cached;
+    let jsonContent = readFileSync(absolutePath, "utf8"), packageJSON = JSON.parse(jsonContent);
+    packageJSON[indentSymbol] = detectIndent(jsonContent).indent ?? 2;
+    let result = {
+      ...packageJSON,
+      dependencies: { ...packageJSON.dependencies || {} },
+      devDependencies: { ...packageJSON.devDependencies || {} },
+      peerDependencies: { ...packageJSON.peerDependencies || {} }
+    };
+    return _JsPackageManager.packageJsonCache.set(absolutePath, result), result;
+  }
+  #getIndent(filePath) {
+    try {
+      return _JsPackageManager.getPackageJson(filePath)[indentSymbol];
+    } catch {
+      return 2;
+    }
+  }
+  writePackageJson(packageJson, directory = this.cwd) {
+    let packageJsonToWrite = { ...packageJson };
+    ["dependencies", "devDependencies", "peerDependencies"].forEach((type) => {
+      packageJsonToWrite[type] && Object.keys(packageJsonToWrite[type]).length === 0 && delete packageJsonToWrite[type];
+    });
+    let filePath = join(directory, "package.json"), indent = this.#getIndent(filePath), packageJsonPath = normalize(resolve(directory, "package.json")), content = `${JSON.stringify(packageJsonToWrite, null, indent)}
+`;
+    writeFileSync(packageJsonPath, content, "utf8");
+    let cachedPackageJson = packageJsonToWrite;
+    cachedPackageJson.dependencies = { ...packageJsonToWrite.dependencies || {} }, cachedPackageJson.devDependencies = { ...packageJsonToWrite.devDependencies || {} }, cachedPackageJson.peerDependencies = { ...packageJsonToWrite.peerDependencies || {} }, cachedPackageJson[indentSymbol] = indent, _JsPackageManager.packageJsonCache.set(packageJsonPath, cachedPackageJson);
+  }
+  getAllDependencies() {
+    let allDependencies = {};
+    for (let packageJsonPath of this.packageJsonPaths) {
+      let packageJson = _JsPackageManager.getPackageJson(packageJsonPath), { dependencies, devDependencies, peerDependencies } = packageJson;
+      Object.assign(allDependencies, dependencies, devDependencies, peerDependencies);
+    }
+    return allDependencies;
+  }
+  isDependencyInstalled(dependency) {
+    return Object.keys(this.getAllDependencies()).includes(dependency);
+  }
+  /**
+   * Resolve the effective version/range of a declared dependency: the installed version if present,
+   * otherwise the declared semver range. Returns null when the package is not declared or only a
+   * non-semver specifier is declared. PNPMProxy additionally resolves pnpm `catalog:` references.
+   */
+  async getDeclaredVersionSpecifier(packageName) {
+    let installed = await this.getInstalledVersion(packageName);
+    if (installed)
+      return installed;
+    let declared = this.getAllDependencies()[packageName];
+    return declared && validRange(declared) ? declared : null;
+  }
+  /**
+   * Pin `packages` to `version`, mirroring how `anchorPackage` is declared. The base implementation
+   * pins each directly (`pkg@version`). PNPMProxy overrides this to honor pnpm catalogs: when
+   * `anchorPackage` is declared through a catalog, the packages are registered in that catalog and
+   * referenced as `catalog:` instead. Returns the install specifiers to write to package.json.
+   */
+  applyVersionToRelatedPackages(packages, version, _anchorPackage) {
+    return packages.map((pkg) => `${pkg}@${version}`);
+  }
+  /**
+   * Add dependencies to a project using `yarn add` or `npm install`.
+   *
+   * @example
+   *
+   * ```ts
+   * addDependencies(options, [
+   *   `@aussieljk/forkbook/react@${storybookVersion}`,
+   *   `@aussieljk/forkbook/addon-links@${linksVersion}`,
+   * ]);
+   * ```
+   *
+   * @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.
+   */
+  async addDependencies(options, dependencies) {
+    let {
+      skipInstall,
+      writeOutputToFile = !0,
+      packageJsonInfo = this.primaryPackageJson
+    } = options;
+    if (skipInstall) {
+      let { operationDir, packageJson } = packageJsonInfo, dependenciesMap = {};
+      for (let dep of dependencies) {
+        let [packageName, packageVersion] = getPackageDetails(dep);
+        dependenciesMap[packageName] = packageVersion ?? "latest";
+      }
+      let targetDeps = packageJson[options.type];
+      Object.assign(targetDeps, dependenciesMap), this.writePackageJson(packageJson, operationDir);
+    } else
+      try {
+        let result = this.runAddDeps(
+          dependencies,
+          options.type === "devDependencies",
+          writeOutputToFile
+        );
+        return this.clearInstalledVersionCache(), result;
+      } catch (e) {
+        throw logger2.error(`
+An error occurred while adding dependencies to your package.json:`), logger2.log(String(e)), e?.fromStorybook ? e : new HandledError(e);
+      }
+  }
+  /**
+   * Removing dependencies from the package.json file, which is found first starting from the
+   * instance root. The method does not run a package manager install like `npm install`.
+   *
+   * @example
+   *
+   * ```ts
+   * removeDependencies([`@aussieljk/forkbook/react`]);
+   * ```
+   *
+   * @param dependencies Contains a list of packages to remove.
+   */
+  async removeDependencies(dependencies) {
+    for (let pjPath of this.packageJsonPaths)
+      try {
+        let packageJson = _JsPackageManager.getPackageJson(pjPath), modified = !1;
+        if (dependencies.forEach((dep) => {
+          packageJson.dependencies && packageJson.dependencies[dep] && (delete packageJson.dependencies[dep], modified = !0), packageJson.devDependencies && packageJson.devDependencies[dep] && (delete packageJson.devDependencies[dep], modified = !0), packageJson.peerDependencies && packageJson.peerDependencies[dep] && (delete packageJson.peerDependencies[dep], modified = !0);
+        }), modified) {
+          this.writePackageJson(packageJson, dirname(pjPath));
+          break;
+        }
+      } catch (e) {
+        logger2.warn(`Could not process ${pjPath} for dependency removal: ${String(e)}`);
+      }
+  }
+  /**
+   * Return an array of strings matching following format: `<storybook_package_name>@<package_latest_version>`
+   *
+   * For packages in the storybook monorepo, when the latest version is equal to the version of the
+   * current CLI the version is not added to the string.
+   *
+   * When a package is in the monorepo, and the version is not equal to the CLI version, the version
+   * is taken from the versions.ts file and added to the string.
+   *
+   * When a package is not in the monorepo, we don't change the package version and return the package name as is.
+   * The package manager will resolve the latest version of the package upon installing it.
+   *
+   * @param packages
+   */
+  getVersionedPackages(packages, options) {
+    return Promise.all(
+      packages.map(async (pkg) => {
+        let [packageName, packageVersion] = getPackageDetails(pkg);
+        if (!(packageName in versions_default))
+          return pkg;
+        if (packageName in versions_default) {
+          let pkgPrNewSpecifier = getPkgPrNewPackageSpecifier(
+            packageName,
+            options?.storybookVersionSpecifier
+          );
+          if (pkgPrNewSpecifier)
+            return `${packageName}@${pkgPrNewSpecifier}`;
+        }
+        let latestInRange = await this.latestVersion(packageName, packageVersion), currentVersion = versions_default[packageName];
+        return currentVersion === latestInRange || !currentVersion ? `${packageName}@^${latestInRange}` : `${packageName}@${currentVersion}`;
+      })
+    );
+  }
+  /**
+   * 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) => 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;
+    packageName in versions_default && (current = versions_default[packageName]);
+    let latest;
+    try {
+      if (latest = await this.latestVersion(packageName, constraint), !latest)
+        throw new Error(`No version found for ${packageName}`);
+    } catch (e) {
+      if (current)
+        return logger2.warn(`
+     ${import_picocolors.default.yellow(String(e))}`), current;
+      throw logger2.error(`
+     ${import_picocolors.default.red(String(e))}`), new HandledError(e);
+    }
+    return `^${current && (!constraint || satisfies(current, constraint)) && gt2(current, latest) ? current : latest}`;
+  }
+  /**
+   * 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) {
+    let cacheKey = constraint ? `${packageName}@${constraint}` : packageName, cachedVersion = _JsPackageManager.latestVersionCache.get(cacheKey);
+    if (cachedVersion)
+      return logger2.debug(`Using cached version for ${packageName}...`), cachedVersion;
+    let result;
+    logger2.debug(`Getting CLI versions from NPM for ${packageName}...`);
+    try {
+      if (!constraint)
+        result = await this.runGetVersions(packageName, !1);
+      else {
+        let latestVersionSatisfyingTheConstraint = (await this.runGetVersions(packageName, !0)).reverse().find((version) => satisfies(version, constraint));
+        invariant(
+          latestVersionSatisfyingTheConstraint != null,
+          `No version satisfying the constraint: ${packageName}${constraint}`
+        ), result = latestVersionSatisfyingTheConstraint;
+      }
+      return _JsPackageManager.latestVersionCache.set(cacheKey, result), result;
+    } catch (e) {
+      return logger2.debug(`Failed to fetch the latest version for ${packageName}: ${String(e)}`), _JsPackageManager.latestVersionCache.set(cacheKey, null), null;
+    }
+  }
+  /**
+   * Clear the latest version cache. Useful for testing or when you want to refresh version
+   * information.
+   *
+   * @param packageName Optional package name to clear only specific entries. If not provided,
+   *   clears all cache.
+   */
+  static clearLatestVersionCache(packageName) {
+    packageName ? Array.from(_JsPackageManager.latestVersionCache.keys()).filter(
+      (key) => key === packageName || key.startsWith(`${packageName}@`)
+    ).forEach((key) => _JsPackageManager.latestVersionCache.delete(key)) : _JsPackageManager.latestVersionCache.clear();
+  }
+  /**
+   * Clear the installed version cache for a specific package or all packages.
+   *
+   * @param packageName Optional package name to clear from cache. If not provided, clears all.
+   */
+  clearInstalledVersionCache(packageName) {
+    packageName ? Array.from(_JsPackageManager.installedVersionCache.keys()).filter(
+      (key) => key.endsWith(`::${packageName}`)
+    ).forEach((key) => _JsPackageManager.installedVersionCache.delete(key)) : _JsPackageManager.installedVersionCache.clear();
+  }
+  /**
+   * Clear both the latest version cache and installed version cache. This should be called after
+   * any operation that modifies dependencies.
+   */
+  clearAllVersionCaches() {
+    _JsPackageManager.clearLatestVersionCache(), this.clearInstalledVersionCache();
+  }
+  addStorybookCommandInScripts(options) {
+    let storybookCmd = `forkbook dev -p ${options?.port ?? 6006}`, buildStorybookCmd = "forkbook build", preCommand = options?.preCommand ? this.getRunCommand(options.preCommand) : void 0;
+    this.addScripts({
+      forkbook: [preCommand, storybookCmd].filter(Boolean).join(" && "),
+      "build-forkbook": [preCommand, buildStorybookCmd].filter(Boolean).join(" && ")
+    });
+  }
+  addScripts(scripts) {
+    let { operationDir, packageJson } = this.#getPrimaryPackageJson();
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      ...scripts
+    }, this.writePackageJson(packageJson, operationDir);
+  }
+  addPackageResolutions(versions) {
+    let { operationDir, packageJson } = this.#getPrimaryPackageJson(), resolutions = this.getResolutions(packageJson, versions);
+    this.writePackageJson({ ...packageJson, ...resolutions }, operationDir);
+  }
+  /** Returns the installed version of a specified package */
+  async getInstalledVersion(packageName) {
+    let cacheKey = packageName;
+    try {
+      let cachedVersion = _JsPackageManager.installedVersionCache.get(cacheKey);
+      if (cachedVersion !== void 0)
+        return logger2.debug(`Using cached installed version for ${packageName}...`), cachedVersion;
+      logger2.debug(`Getting installed version for ${packageName}...`);
+      let version = null, vitePlusVersions = await getVitePlusVersions();
+      if (vitePlusVersions?.[packageName] && (version = vitePlusVersions[packageName]), !version) {
+        let installations = await this.findInstallations([packageName]);
+        installations && (version = Object.entries(installations.dependencies)[0]?.[1]?.[0].version || null);
+      }
+      if (!version)
+        return logger2.debug(`No installations found for ${packageName}`), _JsPackageManager.installedVersionCache.set(cacheKey, null), null;
+      let coercedVersion = coerce(version, { includePrerelease: !0 })?.toString() ?? version;
+      return logger2.debug(`Installed version for ${packageName}: ${coercedVersion}`), _JsPackageManager.installedVersionCache.set(cacheKey, coercedVersion), coercedVersion;
+    } catch (e) {
+      return logger2.error(`Error getting installed version for ${packageName}: ${String(e)}`), _JsPackageManager.installedVersionCache.set(cacheKey, null), null;
+    }
+  }
+  async isPackageInstalled(packageName) {
+    return await this.getInstalledVersion(packageName) !== null;
+  }
+  /**
+   * Searches for a dependency/devDependency in all package.json files and returns the version of
+   * the dependency.
+   */
+  getDependencyVersion(dependency) {
+    return logger2.debug(`Getting dependency version for ${dependency}...`), this.packageJsonPaths.map((path) => {
+      let packageJson = _JsPackageManager.getPackageJson(path);
+      return packageJson.dependencies?.[dependency] ?? packageJson.devDependencies?.[dependency];
+    }).filter(Boolean)[0] ?? null;
+  }
+  // Helper to read and check a package.json for storybook dependency
+  static hasStorybookDependency(packageJsonPath) {
+    try {
+      let content = readFileSync(packageJsonPath, "utf-8"), packageJson = JSON.parse(content);
+      return !!(packageJson.dependencies && packageJson.dependencies.storybook || packageJson.devDependencies && packageJson.devDependencies.storybook);
+    } catch {
+      return !1;
+    }
+  }
+  // Helper to read and check a package.json for storybook dependency
+  static hasAnyStorybookDependency(packageJsonPath) {
+    try {
+      let content = readFileSync(packageJsonPath, "utf-8"), packageJson = JSON.parse(content), allDeps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+      };
+      return Object.keys(allDeps).some(
+        (dep) => dep.includes("storybook") || dep === "@aussieljk/forkbook"
+      );
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * Find the primary package.json file in the project root. The primary package.json file is the
+   * one that contains the `storybook` dependency. If no primary package.json file is found, the
+   * function will return the package.json file in the project root.
+   */
+  #findPrimaryPackageJsonPath() {
+    for (let packageJsonPath of this.packageJsonPaths)
+      if (_JsPackageManager.hasStorybookDependency(packageJsonPath))
+        return packageJsonPath;
+    return this.packageJsonPaths[0] ?? resolve(this.cwd, "package.json");
+  }
+  /** List all package.json files starting from the given directory and stopping at the project root. */
+  static listAllPackageJsonPaths(instanceDir, storiesPaths) {
+    let packageJsonPaths = findFilesUp(["package.json"], instanceDir);
+    if (!storiesPaths)
+      return packageJsonPaths;
+    let projectRoot = getProjectRoot(), relevantPackageJsons = globSync("**/package.json", {
+      cwd: projectRoot,
+      absolute: !0,
+      ignore: ["**/node_modules/**", "**/dist/**"]
+    }).filter((packageJsonPath) => {
+      let packageDir = dirname(packageJsonPath);
+      return storiesPaths.some((storyPath) => storyPath.startsWith(packageDir));
+    });
+    return Array.from(/* @__PURE__ */ new Set([...packageJsonPaths, ...relevantPackageJsons]));
+  }
+  /**
+   * Get the primary package.json file and its operation directory. The primary package.json file is
+   * the one that contains the storybook dependency. If the primary package.json file is not found,
+   * the function returns information about thepackage.json file in the current working directory.
+   */
+  #getPrimaryPackageJson() {
+    let finalTargetPackageJsonPath = this.#findPrimaryPackageJsonPath();
+    return _JsPackageManager.getPackageJsonInfo(finalTargetPackageJsonPath);
+  }
+  static getPackageJsonInfo(packageJsonPath) {
+    logger2.debug(`Getting package.json info for ${packageJsonPath}...`);
+    let operationDir = dirname(packageJsonPath);
+    return {
+      packageJsonPath,
+      operationDir,
+      get packageJson() {
+        return _JsPackageManager.getPackageJson(packageJsonPath);
+      }
+    };
+  }
+};
+
+// src/common/utils/framework.ts
+import {
+  SupportedBuilder,
+  SupportedFramework,
+  SupportedRenderer
+} from "@aussieljk/forkbook/internal/types";
+var frameworkToRenderer = {
+  // frameworks
+  [SupportedFramework.NEXTJS_VITE]: SupportedRenderer.REACT,
+  [SupportedFramework.REACT_VITE]: SupportedRenderer.REACT,
+  // renderers
+  [SupportedRenderer.REACT_NATIVE]: SupportedRenderer.REACT_NATIVE,
+  [SupportedRenderer.REACT]: SupportedRenderer.REACT
+}, frameworkToBuilder = {
+  // frameworks
+  [SupportedFramework.NEXTJS_VITE]: SupportedBuilder.VITE,
+  [SupportedFramework.REACT_VITE]: SupportedBuilder.VITE
+};
+
+// src/common/utils/normalize-path.ts
+import { posix } from "node:path";
+function normalizePath(p) {
+  return posix.normalize(p.replace(/\\/g, "/"));
+}
+
+// src/common/utils/get-addon-names.ts
+var normalizeAddonName = (addon) => {
+  let name = "";
+  if (typeof addon == "string" ? name = addon : typeof addon == "object" && (name = addon.name), !name.startsWith("."))
+    return name = normalizePath(name), name = name.replace(/.*node_modules\//, ""), name.replace(/\/dist\/.*$/, "").replace(/\.[mc]?[tj]?sx?$/, "").replace(/\/register$/, "").replace(/\/manager$/, "").replace(/\/preset$/, "");
+}, getAddonNames = (mainConfig) => (mainConfig.addons || []).map(normalizeAddonName).filter((item) => item != null);
+
+// src/common/utils/default-config-dir.ts
+import { existsSync } from "node:fs";
+import { join as join2 } from "node:path";
+function defaultConfigDir(cwd = process.cwd()) {
+  return !existsSync(join2(cwd, ".forkbook")) && existsSync(join2(cwd, ".storybook")) ? ".storybook" : ".forkbook";
+}
+
+// src/common/utils/get-framework-name.ts
+import { dedent as dedent3 } from "ts-dedent";
+
+// src/common/utils/get-storybook-info.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { basename, dirname as dirname2, join as join4 } from "node:path";
+import {
+  SupportedBuilder as SupportedBuilder2,
+  SupportedFramework as SupportedFramework2,
+  SupportedRenderer as SupportedRenderer2
+} from "@aussieljk/forkbook/internal/types";
+
+// src/common/utils/get-storybook-configuration.ts
+function getStorybookConfiguration(storybookScript, shortName, longName) {
+  if (!storybookScript)
+    return null;
+  let parts = storybookScript.split(/[\s='"]+/), index = parts.indexOf(longName);
+  return index === -1 && (index = parts.indexOf(shortName)), index === -1 ? null : parts[index + 1];
+}
+
+// src/common/utils/load-main-config.ts
+import { readFile, rm, writeFile } from "node:fs/promises";
+import { join as join3, parse, relative, resolve as resolve3 } from "node:path";
+import { logger as logger3 } from "@aussieljk/forkbook/internal/node-logger";
+import { MainFileEvaluationError } from "@aussieljk/forkbook/internal/server-errors";
+import { dedent as dedent2 } from "ts-dedent";
+
+// src/common/utils/interpret-files.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { extname } from "node:path";
+var typescriptFallbackExtensions = {
+  ".js": [".ts", ".tsx"],
+  ".mjs": [".mts"],
+  ".cjs": [".cts"],
+  ".jsx": [".tsx"]
+}, supportedExtensions = storybookConfigExtensions;
+function getInterpretedFile(pathToFile) {
+  return supportedExtensions.map((ext) => pathToFile.endsWith(ext) ? pathToFile : `${pathToFile}${ext}`).find((candidate) => existsSync2(candidate));
+}
+var importResolver = createModuleResolver({
+  extensions: [...supportedExtensions],
+  mainFields: ["module", "main"]
+});
+function resolveImport(id, options) {
+  try {
+    return resolveSync(id, options.basedir);
+  } catch (error) {
+    let ext = extname(id), fallbackExtensions = typescriptFallbackExtensions[ext];
+    if (!fallbackExtensions)
+      throw error;
+    let fallbackError = error, baseId = id.slice(0, -ext.length);
+    for (let fallbackExtension of fallbackExtensions)
+      try {
+        return resolveSync(`${baseId}${fallbackExtension}`, options.basedir);
+      } catch (err) {
+        fallbackError = err;
+      }
+    throw fallbackError;
+  }
+}
+function resolveSync(id, basedir) {
+  return importResolver.resolveSync(basedir, id);
+}
+
+// src/common/utils/validate-configuration-files.ts
+import { resolve as resolve2 } from "node:path";
+import { once } from "@aussieljk/forkbook/internal/node-logger";
+import { MainFileMissingError } from "@aussieljk/forkbook/internal/server-errors";
+import { dedent } from "ts-dedent";
+async function validateConfigurationFiles(configDir, cwd) {
+  let extensionsPattern = `{${Array.from(supportedExtensions).join(",")}}`, mainConfigMatches = await glob(slash(resolve2(configDir, `main${extensionsPattern}`)), {
+    cwd: cwd ?? process.cwd()
+  }), [mainConfigPath] = mainConfigMatches;
+  if (mainConfigMatches.length > 1 && once.warn(dedent`
+      Multiple main files found in your configDir (${resolve2(configDir)}).
+      Forkbook will use the first one found and ignore the others. Please remove the extra files.
+    `), !mainConfigPath)
+    throw new MainFileMissingError({ location: configDir });
+}
+
+// src/common/utils/load-main-config.ts
+async function loadMainConfig({
+  configDir = defaultConfigDir(),
+  cwd,
+  skipCache
+}) {
+  await validateConfigurationFiles(configDir, cwd);
+  let mainPath = getInterpretedFile(resolve3(configDir, "main"));
+  try {
+    let out = await importModule(mainPath, { skipCache });
+    return withForkbookFramework(out);
+  } catch (e) {
+    if (!(e instanceof Error))
+      throw e;
+    if (e.message.includes("not defined in ES module scope")) {
+      logger3.info(
+        "Loading main config failed as the file does not seem to be valid ESM. Trying a temporary fix, please ensure the main config is valid ESM."
+      );
+      let comment = "// end of Forkbook 10 migration assistant header, you can delete the above code", content = await readFile(mainPath, "utf-8");
+      if (!content.includes(comment)) {
+        let header = dedent2`
+          import { createRequire } from "node:module";
+          import { dirname } from "node:path";
+          import { fileURLToPath } from "node:url";
+    
+          const __filename = fileURLToPath(import.meta.url);
+          const __dirname = dirname(__filename);
+          const require = createRequire(import.meta.url);
+        `, { ext, name, dir } = parse(mainPath), modifiedMainPath = join3(dir, `${name}.tmp.${ext}`);
+        await writeFile(modifiedMainPath, [header, comment, content].join(`
+
+`));
+        let out;
+        try {
+          out = await importModule(modifiedMainPath);
+        } finally {
+          await rm(modifiedMainPath);
+        }
+        return withForkbookFramework(out);
+      }
+    }
+    throw new MainFileEvaluationError({
+      location: relative(process.cwd(), mainPath),
+      error: e
+    });
+  }
+}
+
+// src/common/utils/get-storybook-info.ts
+var rendererPackages = {
+  "@aussieljk/forkbook/react": SupportedRenderer2.REACT,
+  "@storybook/react-native": SupportedRenderer2.REACT_NATIVE
+}, frameworkPackages = {
+  "@aussieljk/forkbook/react-vite": SupportedFramework2.REACT_VITE,
+  "@aussieljk/forkbook/nextjs-vite": SupportedFramework2.NEXTJS_VITE
+}, builderPackages = {
+  "@aussieljk/forkbook/builder-vite": SupportedBuilder2.VITE
+}, findDependency = ({ dependencies, devDependencies, peerDependencies }, predicate) => [
+  Object.entries(dependencies || {}).find(predicate),
+  Object.entries(devDependencies || {}).find(predicate),
+  Object.entries(peerDependencies || {}).find(predicate)
+], getStorybookVersionSpecifier = (configDir) => {
+  let packageJsonPaths = JsPackageManager.listAllPackageJsonPaths(dirname2(configDir));
+  for (let packageJsonPath of packageJsonPaths) {
+    let packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8")), [dep, devDep, peerDep] = findDependency(
+      packageJson,
+      ([key]) => key === "@aussieljk/forkbook"
+    ), [pkg, version] = dep || devDep || peerDep || [];
+    if (pkg && version)
+      return version;
+  }
+}, findConfigFile = (prefix, configDir) => {
+  let filePrefix = join4(configDir, prefix), extension = storybookConfigExtensions.find((ext) => existsSync3(`${filePrefix}${ext}`));
+  return extension ? `${filePrefix}${extension}` : null;
+}, getConfigInfo = (configDir) => {
+  let storybookConfigDir = configDir ?? defaultConfigDir();
+  if (!existsSync3(storybookConfigDir)) {
+    let packageJsonPaths = JsPackageManager.listAllPackageJsonPaths(storybookConfigDir);
+    for (let packageJsonPath of packageJsonPaths) {
+      let packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8")), storybookScript = packageJson.scripts?.forkbook ?? packageJson.scripts?.storybook;
+      if (storybookScript && !configDir) {
+        let configParam = getStorybookConfiguration(storybookScript, "-c", "--config-dir");
+        if (configParam) {
+          storybookConfigDir = configParam;
+          break;
+        }
+      }
+    }
+  }
+  return {
+    configDir: storybookConfigDir,
+    mainConfigPath: findConfigFile("main", storybookConfigDir),
+    previewConfigPath: findConfigFile("preview", storybookConfigDir),
+    managerConfigPath: findConfigFile("manager", storybookConfigDir)
+  };
+}, getStorybookInfo = async (configDir = defaultConfigDir(), cwd, { skipCache } = {}) => {
+  let configInfo = getConfigInfo(configDir), mainConfig = await loadMainConfig({
+    configDir: configInfo.configDir,
+    cwd,
+    // When the main config may have been rewritten earlier in the same process (e.g. by
+    // `forkbook add`), callers must skip the module cache to read the
+    // current on-disk config instead of a stale, previously-evaluated version.
+    skipCache
+  });
+  invariant(mainConfig, `Unable to find or evaluate ${configInfo.mainConfigPath}`);
+  let frameworkValue = mainConfig.framework, frameworkField = typeof frameworkValue == "string" ? frameworkValue : frameworkValue?.name, addons = getAddonNames(mainConfig), versionSpecifier = getStorybookVersionSpecifier(configDir);
+  if (!frameworkField)
+    return basename(configInfo.configDir) === RN_STORYBOOK_DIR ? {
+      ...configInfo,
+      versionSpecifier,
+      addons,
+      mainConfig,
+      frameworkPackage: "@storybook/react-native",
+      rendererPackage: "@storybook/react-native",
+      renderer: SupportedRenderer2.REACT_NATIVE,
+      mainConfigPath: configInfo.mainConfigPath ?? void 0,
+      previewConfigPath: configInfo.previewConfigPath ?? void 0,
+      managerConfigPath: configInfo.managerConfigPath ?? void 0
+    } : {
+      ...configInfo,
+      versionSpecifier,
+      addons,
+      mainConfig,
+      mainConfigPath: configInfo.mainConfigPath ?? void 0,
+      previewConfigPath: configInfo.previewConfigPath ?? void 0,
+      managerConfigPath: configInfo.managerConfigPath ?? void 0
+    };
+  let frameworkPackage = extractFrameworkPackageName(frameworkField), framework = frameworkPackages[frameworkPackage], renderer = await extractRenderer(frameworkPackage), builder = frameworkToBuilder[framework], rendererPackage = Object.entries(rendererPackages).find(
+    ([, value]) => value === renderer
+  )?.[0], builderPackage = Object.entries(builderPackages).find(
+    ([, value]) => value === builder
+  )?.[0];
+  return {
+    ...configInfo,
+    addons,
+    mainConfig,
+    framework,
+    versionSpecifier,
+    renderer: renderer ?? void 0,
+    builder: builder ?? void 0,
+    frameworkPackage,
+    rendererPackage,
+    builderPackage,
+    mainConfigPath: configInfo.mainConfigPath ?? void 0,
+    previewConfigPath: configInfo.previewConfigPath ?? void 0,
+    managerConfigPath: configInfo.managerConfigPath ?? void 0
+  };
+};
+
+// src/common/utils/get-framework-name.ts
+async function getFrameworkName(options) {
+  let framework = await options.presets.apply("framework", "", options);
+  if (!framework)
+    throw new Error(dedent3`
+      You must specify a framework in '.forkbook/main.js' config.
+
+      https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#framework-field-mandatory
+    `);
+  return typeof framework == "object" ? framework.name : framework;
+}
+var storybookFrameworkNames = {
+  "@storybook/react-vite": "@aussieljk/forkbook/react-vite",
+  "@storybook/nextjs-vite": "@aussieljk/forkbook/nextjs-vite"
+};
+function forkbookFramework(framework) {
+  let name = typeof framework == "string" ? framework : framework?.name, forkbookName = name ? storybookFrameworkNames[name] : void 0;
+  return forkbookName ? typeof framework == "string" ? forkbookName : { ...framework, name: forkbookName } : framework;
+}
+function withForkbookFramework(config) {
+  let framework = forkbookFramework(config?.framework);
+  return framework === config?.framework ? config : { ...config, framework };
+}
+var extractFrameworkPackageName = (framework) => {
+  let normalizedPath = normalizePath(forkbookFramework(framework));
+  return Object.keys(frameworkPackages).find((pkg) => normalizedPath.endsWith(pkg)) ?? framework;
+};
+
+// src/common/utils/get-renderer-name.ts
+async function getRendererName(options) {
+  let core = await options.presets.apply("core", {}, options);
+  return !core || !core.renderer ? getFrameworkName(options) : core.renderer;
+}
+async function extractRenderer(frameworkName) {
+  let extractedFrameworkName = extractFrameworkPackageName(frameworkName), framework = frameworkPackages[extractedFrameworkName];
+  return framework ? frameworkToRenderer[framework] : null;
+}
+
+export {
+  versions_default,
+  HandledError,
+  isPkgPrNewVersionSpecifier,
+  getPkgPrNewPackageSpecifier,
+  FORKBOOK_PACKAGE_PATTERNS,
+  hasStorybookMinimumAgeExclusions,
+  parsePackageData,
+  parsePositiveIntegerConfigValue,
+  parseReleaseTime,
+  parsePackageTimeMap,
+  getAgeInMinutes,
+  getLatestStableVersionAdheringToMinimumAgeGate,
+  getVitestStorybookRunCommand,
+  getMswInitCommand,
+  FORKBOOK_RERUN_INSTRUCTION,
+  getStorybookRerunCommand,
+  getErrorLogs,
+  INSTALL_ERROR_TAIL_LINES,
+  getInstallErrorTail,
+  getVitePlusVersions,
+  clearVitePlusCache,
+  PackageManagerName,
+  getPrettyPackageManagerName,
+  getPackageDetails,
+  JsPackageManager,
+  frameworkToRenderer,
+  frameworkToBuilder,
+  normalizeAddonName,
+  getAddonNames,
+  defaultConfigDir,
+  getRendererName,
+  extractRenderer,
+  getStorybookConfiguration,
+  supportedExtensions,
+  getInterpretedFile,
+  resolveImport,
+  validateConfigurationFiles,
+  loadMainConfig,
+  rendererPackages,
+  frameworkPackages,
+  builderPackages,
+  findConfigFile,
+  getConfigInfo,
+  getStorybookInfo,
+  getFrameworkName,
+  forkbookFramework,
+  withForkbookFramework,
+  extractFrameworkPackageName
+};