storybook 9.0.11 → 9.0.13

package/dist/cli/index.d.ts

@@ -1,6 +1,9 @@
-import { PackageJsonWithMaybeDeps, JsPackageManager as JsPackageManager$1, PackageJsonWithDepsAndDevDeps, PackageJson } from 'storybook/internal/common';
-import { SupportedFrameworks, SupportedRenderers } from 'storybook/internal/types';
+import { PackageJsonWithMaybeDeps, JsPackageManager as JsPackageManager$1, PackageJson } from 'storybook/internal/common';
+import { SupportedFrameworks, SupportedRenderers, PackageJson as PackageJson$1 } from 'storybook/internal/types';
 import * as semver from 'semver';
+import { Buffer } from 'node:buffer';
+import { ChildProcess } from 'node:child_process';
+import { Readable, Writable, Stream } from 'node:stream';
 
 /** A list of all frameworks that are supported, but use a package outside the storybook monorepo */
 type ExternalFramework = {
@@ -118,10 +121,10 @@ declare const writeFileAsJson: (jsonPath: string, content: unknown) => boolean;
  * ]);
  * ```
  *
- * @param {Object} packageJson The current package.json so we can inspect its contents
- * @returns {Array} Contains the packages and versions that need to be installed
+ * @param packageJson The current package.json so we can inspect its contents
+ * @returns Contains the packages and versions that need to be installed
  */
-declare function getBabelDependencies(packageManager: JsPackageManager$1, packageJson: PackageJsonWithDepsAndDevDeps): Promise<string[]>;
+declare function getBabelDependencies(packageManager: JsPackageManager$1): Promise<string[]>;
 declare function addToDevDependenciesIfNotPresent(packageJson: PackageJson, name: string, packageVersion: string): void;
 declare function copyTemplate(templateRoot: string, destination?: string): void;
 type CopyTemplateFilesOptions = {
@@ -141,10 +144,9 @@ declare function getVersionSafe(packageManager: JsPackageManager$1, packageName:
 declare const cliStoriesTargetPath: () => Promise<"./src/stories" | "./stories">;
 declare function copyTemplateFiles({ packageManager, templateLocation, language, destination, commonAssetsDir, features, }: CopyTemplateFilesOptions): Promise<void>;
 declare function adjustTemplate(templatePath: string, templateData: Record<string, any>): Promise<void>;
-declare function getStorybookVersionSpecifier(packageJson: PackageJsonWithDepsAndDevDeps): string | undefined;
 declare function isNxProject(): Promise<string | undefined>;
 declare function coerceSemver(version: string): semver.SemVer;
-declare function hasStorybookDependencies(packageManager: JsPackageManager$1): Promise<boolean>;
+declare function hasStorybookDependencies(packageManager: JsPackageManager$1): boolean;
 
 declare const ANGULAR_JSON_PATH = "angular.json";
 declare const compoDocPreviewPrefix: string;
@@ -187,16 +189,711 @@ declare class AngularJSON {
 
 declare function getRendererDir(packageManager: JsPackageManager$1, renderer: SupportedFrameworks | SupportedRenderers): Promise<string>;
 
-type NpmOptions = {
-    skipInstall?: boolean;
-    installAsDevDependencies?: boolean;
+type StdioOption =
+	| 'pipe'
+	| 'overlapped'
+	| 'ipc'
+	| 'ignore'
+	| 'inherit'
+	| Stream
+	| number
+	| undefined;
+
+type EncodingOption =
+  | 'utf8'
+  // eslint-disable-next-line unicorn/text-encoding-identifier-case
+  | 'utf-8'
+  | 'utf16le'
+  | 'utf-16le'
+  | 'ucs2'
+  | 'ucs-2'
+  | 'latin1'
+  | 'binary'
+  | 'ascii'
+  | 'hex'
+  | 'base64'
+  | 'base64url'
+  | 'buffer'
+  | null
+  | undefined;
+type DefaultEncodingOption = 'utf8';
+
+type CommonOptions<EncodingType extends EncodingOption = DefaultEncodingOption> = {
+	/**
+	Kill the spawned process when the parent process exits unless either:
+		- the spawned process is [`detached`](https://nodejs.org/api/child_process.html#child_process_options_detached)
+		- the parent process is terminated abruptly, for example, with `SIGKILL` as opposed to `SIGTERM` or a normal exit
+
+	@default true
+	*/
+	readonly cleanup?: boolean;
+
+	/**
+	Prefer locally installed binaries when looking for a binary to execute.
+
+	If you `$ npm install foo`, you can then `execa('foo')`.
+
+	@default `true` with `$`, `false` otherwise
+	*/
+	readonly preferLocal?: boolean;
+
+	/**
+	Preferred path to find locally installed binaries in (use with `preferLocal`).
+
+	@default process.cwd()
+	*/
+	readonly localDir?: string | URL;
+
+	/**
+	Path to the Node.js executable to use in child processes.
+
+	This can be either an absolute path or a path relative to the `cwd` option.
+
+	Requires `preferLocal` to be `true`.
+
+	For example, this can be used together with [`get-node`](https://github.com/ehmicky/get-node) to run a specific Node.js version in a child process.
+
+	@default process.execPath
+	*/
+	readonly execPath?: string;
+
+	/**
+	Buffer the output from the spawned process. When set to `false`, you must read the output of `stdout` and `stderr` (or `all` if the `all` option is `true`). Otherwise the returned promise will not be resolved/rejected.
+
+	If the spawned process fails, `error.stdout`, `error.stderr`, and `error.all` will contain the buffered data.
+
+	@default true
+	*/
+	readonly buffer?: boolean;
+
+	/**
+	Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+
+	@default `inherit` with `$`, `pipe` otherwise
+	*/
+	readonly stdin?: StdioOption;
+
+	/**
+	Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+
+	@default 'pipe'
+	*/
+	readonly stdout?: StdioOption;
+
+	/**
+	Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+
+	@default 'pipe'
+	*/
+	readonly stderr?: StdioOption;
+
+	/**
+	Setting this to `false` resolves the promise with the error instead of rejecting it.
+
+	@default true
+	*/
+	readonly reject?: boolean;
+
+	/**
+	Add an `.all` property on the promise and the resolved value. The property contains the output of the process with `stdout` and `stderr` interleaved.
+
+	@default false
+	*/
+	readonly all?: boolean;
+
+	/**
+	Strip the final [newline character](https://en.wikipedia.org/wiki/Newline) from the output.
+
+	@default true
+	*/
+	readonly stripFinalNewline?: boolean;
+
+	/**
+	Set to `false` if you don't want to extend the environment variables when providing the `env` property.
+
+	@default true
+	*/
+	readonly extendEnv?: boolean;
+
+	/**
+	Current working directory of the child process.
+
+	@default process.cwd()
+	*/
+	readonly cwd?: string | URL;
+
+	/**
+	Environment key-value pairs. Extends automatically from `process.env`. Set `extendEnv` to `false` if you don't want this.
+
+	@default process.env
+	*/
+	readonly env?: NodeJS.ProcessEnv;
+
+	/**
+	Explicitly set the value of `argv[0]` sent to the child process. This will be set to `command` or `file` if not specified.
+	*/
+	readonly argv0?: string;
+
+	/**
+	Child's [stdio](https://nodejs.org/api/child_process.html#child_process_options_stdio) configuration.
+
+	@default 'pipe'
+	*/
+	readonly stdio?: 'pipe' | 'overlapped' | 'ignore' | 'inherit' | readonly StdioOption[];
+
+	/**
+	Specify the kind of serialization used for sending messages between processes when using the `stdio: 'ipc'` option or `execaNode()`:
+		- `json`: Uses `JSON.stringify()` and `JSON.parse()`.
+		- `advanced`: Uses [`v8.serialize()`](https://nodejs.org/api/v8.html#v8_v8_serialize_value)
+
+	[More info.](https://nodejs.org/api/child_process.html#child_process_advanced_serialization)
+
+	@default 'json'
+	*/
+	readonly serialization?: 'json' | 'advanced';
+
+	/**
+	Prepare child to run independently of its parent process. Specific behavior [depends on the platform](https://nodejs.org/api/child_process.html#child_process_options_detached).
+
+	@default false
+	*/
+	readonly detached?: boolean;
+
+	/**
+	Sets the user identity of the process.
+	*/
+	readonly uid?: number;
+
+	/**
+	Sets the group identity of the process.
+	*/
+	readonly gid?: number;
+
+	/**
+	If `true`, runs `command` inside of a shell. Uses `/bin/sh` on UNIX and `cmd.exe` on Windows. A different shell can be specified as a string. The shell should understand the `-c` switch on UNIX or `/d /s /c` on Windows.
+
+	We recommend against using this option since it is:
+	- not cross-platform, encouraging shell-specific syntax.
+	- slower, because of the additional shell interpretation.
+	- unsafe, potentially allowing command injection.
+
+	@default false
+	*/
+	readonly shell?: boolean | string;
+
+	/**
+	Specify the character encoding used to decode the `stdout` and `stderr` output. If set to `'buffer'` or `null`, then `stdout` and `stderr` will be a `Buffer` instead of a string.
+
+	@default 'utf8'
+	*/
+	readonly encoding?: EncodingType;
+
+	/**
+	If `timeout` is greater than `0`, the parent will send the signal identified by the `killSignal` property (the default is `SIGTERM`) if the child runs longer than `timeout` milliseconds.
+
+	@default 0
+	*/
+	readonly timeout?: number;
+
+	/**
+	Largest amount of data in bytes allowed on `stdout` or `stderr`. Default: 100 MB.
+
+	@default 100_000_000
+	*/
+	readonly maxBuffer?: number;
+
+	/**
+	Signal value to be used when the spawned process will be killed.
+
+	@default 'SIGTERM'
+	*/
+	readonly killSignal?: string | number;
+
+	/**
+	You can abort the spawned process using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
+
+	When `AbortController.abort()` is called, [`.isCanceled`](https://github.com/sindresorhus/execa#iscanceled) becomes `true`.
+
+	@example
+	```
+	import {execa} from 'execa';
+
+	const abortController = new AbortController();
+	const subprocess = execa('node', [], {signal: abortController.signal});
+
+	setTimeout(() => {
+		abortController.abort();
+	}, 1000);
+
+	try {
+		await subprocess;
+	} catch (error) {
+		console.log(subprocess.killed); // true
+		console.log(error.isCanceled); // true
+	}
+	```
+	*/
+	readonly signal?: AbortSignal;
+
+	/**
+	If `true`, no quoting or escaping of arguments is done on Windows. Ignored on other platforms. This is set to `true` automatically when the `shell` option is `true`.
+
+	@default false
+	*/
+	readonly windowsVerbatimArguments?: boolean;
+
+	/**
+	On Windows, do not create a new console window. Please note this also prevents `CTRL-C` [from working](https://github.com/nodejs/node/issues/29837) on Windows.
+
+	@default true
+	*/
+	readonly windowsHide?: boolean;
+
+	/**
+	Print each command on `stderr` before executing it.
+
+	This can also be enabled by setting the `NODE_DEBUG=execa` environment variable in the current process.
+
+	@default false
+	*/
+	readonly verbose?: boolean;
+};
+
+type StdoutStderrAll = string | Buffer | undefined;
+
+type ExecaReturnBase<StdoutStderrType extends StdoutStderrAll> = {
+	/**
+	The file and arguments that were run, for logging purposes.
+
+	This is not escaped and should not be executed directly as a process, including using `execa()` or `execaCommand()`.
+	*/
+	command: string;
+
+	/**
+	Same as `command` but escaped.
+
+	This is meant to be copy and pasted into a shell, for debugging purposes.
+	Since the escaping is fairly basic, this should not be executed directly as a process, including using `execa()` or `execaCommand()`.
+	*/
+	escapedCommand: string;
+
+	/**
+	The numeric exit code of the process that was run.
+	*/
+	exitCode: number;
+
+	/**
+	The output of the process on stdout.
+	*/
+	stdout: StdoutStderrType;
+
+	/**
+	The output of the process on stderr.
+	*/
+	stderr: StdoutStderrType;
+
+	/**
+	Whether the process failed to run.
+	*/
+	failed: boolean;
+
+	/**
+	Whether the process timed out.
+	*/
+	timedOut: boolean;
+
+	/**
+	Whether the process was killed.
+	*/
+	killed: boolean;
+
+	/**
+	The name of the signal that was used to terminate the process. For example, `SIGFPE`.
+
+	If a signal terminated the process, this property is defined and included in the error message. Otherwise it is `undefined`.
+	*/
+	signal?: string;
+
+	/**
+	A human-friendly description of the signal that was used to terminate the process. For example, `Floating point arithmetic error`.
+
+	If a signal terminated the process, this property is defined and included in the error message. Otherwise it is `undefined`. It is also `undefined` when the signal is very uncommon which should seldomly happen.
+	*/
+	signalDescription?: string;
+
+	/**
+	The `cwd` of the command if provided in the command options. Otherwise it is `process.cwd()`.
+	*/
+	cwd: string;
+};
+
+type ExecaSyncReturnValue<StdoutStderrType extends StdoutStderrAll = string> = {
+} & ExecaReturnBase<StdoutStderrType>;
+
+/**
+Result of a child process execution. On success this is a plain object. On failure this is also an `Error` instance.
+
+The child process fails when:
+- its exit code is not `0`
+- it was killed with a signal
+- timing out
+- being canceled
+- there's not enough memory or there are already too many child processes
+*/
+type ExecaReturnValue<StdoutStderrType extends StdoutStderrAll = string> = {
+	/**
+	The output of the process with `stdout` and `stderr` interleaved.
+
+	This is `undefined` if either:
+	- the `all` option is `false` (default value)
+	- `execaSync()` was used
+	*/
+	all?: StdoutStderrType;
+
+	/**
+	Whether the process was canceled.
+
+	You can cancel the spawned process using the [`signal`](https://github.com/sindresorhus/execa#signal-1) option.
+	*/
+	isCanceled: boolean;
+} & ExecaSyncReturnValue<StdoutStderrType>;
+
+type ExecaSyncError<StdoutStderrType extends StdoutStderrAll = string> = {
+	/**
+	Error message when the child process failed to run. In addition to the underlying error message, it also contains some information related to why the child process errored.
+
+	The child process stderr then stdout are appended to the end, separated with newlines and not interleaved.
+	*/
+	message: string;
+
+	/**
+	This is the same as the `message` property except it does not include the child process stdout/stderr.
+	*/
+	shortMessage: string;
+
+	/**
+	Original error message. This is the same as the `message` property except it includes neither the child process stdout/stderr nor some additional information added by Execa.
+
+	This is `undefined` unless the child process exited due to an `error` event or a timeout.
+	*/
+	originalMessage?: string;
+} & Error & ExecaReturnBase<StdoutStderrType>;
+
+type ExecaError<StdoutStderrType extends StdoutStderrAll = string> = {
+	/**
+	The output of the process with `stdout` and `stderr` interleaved.
+
+	This is `undefined` if either:
+	- the `all` option is `false` (default value)
+	- `execaSync()` was used
+	*/
+	all?: StdoutStderrType;
+
+	/**
+	Whether the process was canceled.
+	*/
+	isCanceled: boolean;
+} & ExecaSyncError<StdoutStderrType>;
+
+type KillOptions = {
+	/**
+	Milliseconds to wait for the child process to terminate before sending `SIGKILL`.
+
+	Can be disabled with `false`.
+
+	@default 5000
+	*/
+	forceKillAfterTimeout?: number | false;
+};
+
+type ExecaChildPromise<StdoutStderrType extends StdoutStderrAll> = {
+	/**
+	Stream combining/interleaving [`stdout`](https://nodejs.org/api/child_process.html#child_process_subprocess_stdout) and [`stderr`](https://nodejs.org/api/child_process.html#child_process_subprocess_stderr).
+
+	This is `undefined` if either:
+		- the `all` option is `false` (the default value)
+		- both `stdout` and `stderr` options are set to [`'inherit'`, `'ipc'`, `Stream` or `integer`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio)
+	*/
+	all?: Readable;
+
+	catch<ResultType = never>(
+		onRejected?: (reason: ExecaError<StdoutStderrType>) => ResultType | PromiseLike<ResultType>
+	): Promise<ExecaReturnValue<StdoutStderrType> | ResultType>;
+
+	/**
+	Same as the original [`child_process#kill()`](https://nodejs.org/api/child_process.html#child_process_subprocess_kill_signal), except if `signal` is `SIGTERM` (the default value) and the child process is not terminated after 5 seconds, force it by sending `SIGKILL`. Note that this graceful termination does not work on Windows, because Windows [doesn't support signals](https://nodejs.org/api/process.html#process_signal_events) (`SIGKILL` and `SIGTERM` has the same effect of force-killing the process immediately.) If you want to achieve graceful termination on Windows, you have to use other means, such as [`taskkill`](https://github.com/sindresorhus/taskkill).
+	*/
+	kill(signal?: string, options?: KillOptions): void;
+
+	/**
+	Similar to [`childProcess.kill()`](https://nodejs.org/api/child_process.html#child_process_subprocess_kill_signal). This used to be preferred when cancelling the child process execution as the error is more descriptive and [`childProcessResult.isCanceled`](#iscanceled) is set to `true`. But now this is deprecated and you should either use `.kill()` or the `signal` option when creating the child process.
+	*/
+	cancel(): void;
+
+	/**
+	[Pipe](https://nodejs.org/api/stream.html#readablepipedestination-options) the child process's `stdout` to `target`, which can be:
+	- Another `execa()` return value
+	- A writable stream
+	- A file path string
+
+	If the `target` is another `execa()` return value, it is returned. Otherwise, the original `execa()` return value is returned. This allows chaining `pipeStdout()` then `await`ing the final result.
+
+	The `stdout` option] must be kept as `pipe`, its default value.
+	*/
+	pipeStdout?<Target extends ExecaChildPromise<StdoutStderrAll>>(target: Target): Target;
+	pipeStdout?(target: Writable | string): ExecaChildProcess<StdoutStderrType>;
+
+	/**
+	Like `pipeStdout()` but piping the child process's `stderr` instead.
+
+	The `stderr` option must be kept as `pipe`, its default value.
+	*/
+	pipeStderr?<Target extends ExecaChildPromise<StdoutStderrAll>>(target: Target): Target;
+	pipeStderr?(target: Writable | string): ExecaChildProcess<StdoutStderrType>;
+
+	/**
+	Combines both `pipeStdout()` and `pipeStderr()`.
+
+	Either the `stdout` option or the `stderr` option must be kept as `pipe`, their default value. Also, the `all` option must be set to `true`.
+	*/
+	pipeAll?<Target extends ExecaChildPromise<StdoutStderrAll>>(target: Target): Target;
+	pipeAll?(target: Writable | string): ExecaChildProcess<StdoutStderrType>;
+};
+
+type ExecaChildProcess<StdoutStderrType extends StdoutStderrAll = string> = ChildProcess &
+ExecaChildPromise<StdoutStderrType> &
+Promise<ExecaReturnValue<StdoutStderrType>>;
+
+type PackageJsonWithDepsAndDevDeps = PackageJson$1 & Required<Pick<PackageJson$1, 'dependencies' | 'devDependencies'>>;
+
+type PackageMetadata = {
+    version: string;
+    location?: string;
+    reasons?: string[];
+};
+type InstallationMetadata = {
+    dependencies: Record<string, PackageMetadata[]>;
+    duplicatedDependencies: Record<string, string[]>;
+    infoCommand: string;
+    dedupeCommand: string;
 };
 
-type JsPackageManager = any;
+type PackageManagerName = 'npm' | 'yarn1' | 'yarn2' | 'pnpm' | 'bun';
+interface JsPackageManagerOptions {
+    cwd?: string;
+    configDir?: string;
+    storiesPaths?: string[];
+}
+type PackageJsonInfo = {
+    packageJsonPath: string;
+    operationDir: string;
+    packageJson: PackageJsonWithDepsAndDevDeps;
+};
+declare abstract class JsPackageManager {
+    #private;
+    abstract readonly type: PackageManagerName;
+    /** The path to the primary package.json file (contains the `storybook` dependency). */
+    readonly primaryPackageJson: PackageJsonInfo;
+    /** The paths to all package.json files in the project root. */
+    packageJsonPaths: string[];
+    /**
+     * The path to the Storybook instance directory. This is used to find the primary package.json
+     * file in a repository.
+     */
+    readonly instanceDir: string;
+    /** The current working directory. */
+    protected readonly cwd: string;
+    /** Cache for latest version results to avoid repeated network calls. */
+    static readonly latestVersionCache: Map<string, string | null>;
+    /** Cache for installed version results to avoid repeated file system calls. */
+    static readonly installedVersionCache: Map<string, string | null>;
+    constructor(options?: JsPackageManagerOptions);
+    /** Runs arbitrary package scripts. */
+    abstract getRunCommand(command: string): string;
+    /**
+     * Run a command from a local or remote. Fetches a package from the registry without installing it
+     * as a dependency, hotloads it, and runs whatever default command binary it exposes.
+     */
+    abstract getRemoteRunCommand(pkg: string, args: string[], specifier?: string): string;
+    /** Get the package.json file for a given module. */
+    abstract getModulePackageJSON(packageName: string): PackageJson$1 | null;
+    isStorybookInMonorepo(): boolean;
+    installDependencies(options?: {
+        force?: boolean;
+    }): Promise<void>;
+    dedupeDependencies(options?: {
+        force?: boolean;
+    }): Promise<void>;
+    /** Read the `package.json` file available in the provided directory */
+    static getPackageJson(packageJsonPath: string): PackageJsonWithDepsAndDevDeps;
+    writePackageJson(packageJson: PackageJson$1, directory?: string): void;
+    getAllDependencies(): Record<string, string>;
+    isDependencyInstalled(dependency: string): boolean;
+    /**
+     * Add dependencies to a project using `yarn add` or `npm install`.
+     *
+     * @example
+     *
+     * ```ts
+     * addDependencies(options, [
+     *   `@storybook/react@${storybookVersion}`,
+     *   `@storybook/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.
+     */
+    addDependencies(options: {
+        skipInstall: true;
+        type: 'dependencies' | 'devDependencies' | 'peerDependencies';
+        writeOutputToFile?: boolean;
+        packageJsonInfo?: PackageJsonInfo;
+    } | {
+        skipInstall?: false;
+        type: 'dependencies' | 'devDependencies';
+        writeOutputToFile?: boolean;
+        packageJsonInfo?: PackageJsonInfo;
+    }, dependencies: string[]): Promise<void | ExecaChildProcess>;
+    /**
+     * 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([`@storybook/react`]);
+     * ```
+     *
+     * @param dependencies Contains a list of packages to remove.
+     */
+    removeDependencies(dependencies: string[]): Promise<void>;
+    /**
+     * Return an array of strings matching following format: `<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.
+     *
+     * @param packages
+     */
+    getVersionedPackages(packages: string[]): Promise<string[]>;
+    /**
+     * 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: string[]): Promise<string[]>;
+    /**
+     * 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'
+     */
+    getVersion(packageName: string, constraint?: string): Promise<string>;
+    /**
+     * 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
+     */
+    latestVersion(packageName: string, constraint?: string): Promise<string | 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?: string): void;
+    /**
+     * 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?: string): void;
+    /**
+     * Clear both the latest version cache and installed version cache. This should be called after
+     * any operation that modifies dependencies.
+     */
+    clearAllVersionCaches(): void;
+    addStorybookCommandInScripts(options?: {
+        port: number;
+        preCommand?: string;
+    }): void;
+    addScripts(scripts: Record<string, string>): void;
+    addPackageResolutions(versions: Record<string, string>): void;
+    protected abstract runInstall(options?: {
+        force?: boolean;
+    }): ExecaChildProcess;
+    protected abstract runAddDeps(dependencies: string[], installAsDevDependencies: boolean, writeOutputToFile?: boolean): ExecaChildProcess;
+    protected abstract getResolutions(packageJson: PackageJson$1, versions: Record<string, string>): Record<string, any>;
+    /**
+     * Get the latest or all versions of the input package available on npmjs.com
+     *
+     * @param packageName Name of the package
+     * @param fetchAllVersions Should return
+     */
+    protected abstract runGetVersions<T extends boolean>(packageName: string, fetchAllVersions: T): Promise<T extends true ? string[] : string>;
+    abstract getRegistryURL(): Promise<string | undefined>;
+    abstract runInternalCommand(command: string, args: string[], cwd?: string, stdio?: 'inherit' | 'pipe' | 'ignore'): ExecaChildProcess;
+    abstract runPackageCommand(command: string, args: string[], cwd?: string, stdio?: 'inherit' | 'pipe' | 'ignore'): ExecaChildProcess;
+    abstract runPackageCommandSync(command: string, args: string[], cwd?: string, stdio?: 'inherit' | 'pipe' | 'ignore'): string;
+    abstract findInstallations(pattern?: string[]): Promise<InstallationMetadata | undefined>;
+    abstract findInstallations(pattern?: string[], options?: {
+        depth: number;
+    }): Promise<InstallationMetadata | undefined>;
+    abstract parseErrorFromLogs(logs?: string): string;
+    executeCommandSync({ command, args, stdio, cwd, ignoreError, env, ...execaOptions }: CommonOptions<'utf8'> & {
+        command: string;
+        args: string[];
+        cwd?: string;
+        ignoreError?: boolean;
+    }): string;
+    /**
+     * Execute a command asynchronously and return the execa process. This allows you to hook into
+     * stdout/stderr streams and monitor the process.
+     *
+     * @example Const process = packageManager.executeCommand({ command: 'npm', args: ['install'] });
+     * process.stdout?.on('data', (data) => console.log(data.toString())); const result = await
+     * process;
+     */
+    executeCommand({ command, args, stdio, cwd, ignoreError, env, ...execaOptions }: CommonOptions<'utf8'> & {
+        command: string;
+        args: string[];
+        cwd?: string;
+        ignoreError?: boolean;
+    }): ExecaChildProcess;
+    /** Returns the installed (within node_modules or pnp zip) version of a specified package */
+    getInstalledVersion(packageName: string): Promise<string | null>;
+    isPackageInstalled(packageName: string): Promise<boolean>;
+    /**
+     * Searches for a dependency/devDependency in all package.json files and returns the version of
+     * the dependency.
+     */
+    getDependencyVersion(dependency: string): string | null;
+    static hasStorybookDependency(packageJsonPath: string): boolean;
+    static hasAnyStorybookDependency(packageJsonPath: string): boolean;
+    /** List all package.json files starting from the given directory and stopping at the project root. */
+    static listAllPackageJsonPaths(instanceDir: string, storiesPaths?: string[]): string[];
+    static getPackageJsonInfo(packageJsonPath: string): PackageJsonInfo;
+}
+
+type NpmOptions = Parameters<JsPackageManager['addDependencies']>[0];
+
 declare const SUPPORTED_ESLINT_EXTENSIONS: string[];
-declare const findEslintFile: () => Promise<string | undefined>;
+declare const findEslintFile: (instanceDir: string) => Promise<string | undefined>;
 declare const configureFlatConfig: (code: string) => Promise<string>;
-declare function extractEslintInfo(packageManager: JsPackageManager): Promise<{
+declare function extractEslintInfo(packageManager: JsPackageManager$1): Promise<{
     hasEslint: boolean;
     isStorybookPluginInstalled: boolean;
     eslintConfigFile: string | undefined;
@@ -206,7 +903,7 @@ declare function extractEslintInfo(packageManager: JsPackageManager): Promise<{
 declare const normalizeExtends: (existingExtends: any) => string[];
 declare function configureEslintPlugin({ eslintConfigFile, packageManager, isFlatConfig, }: {
     eslintConfigFile: string | undefined;
-    packageManager: JsPackageManager;
+    packageManager: JsPackageManager$1;
     isFlatConfig: boolean;
 }): Promise<void>;
 declare const suggestESLintPlugin: () => Promise<boolean>;
@@ -1184,4 +1881,4 @@ declare class Settings {
     save(): Promise<void>;
 }
 
-export { ANGULAR_JSON_PATH, AngularJSON, type Builder, CommunityBuilder, CoreBuilder, CoreWebpackCompilers, type ExternalFramework, type NpmOptions, ProjectType, SUPPORTED_ESLINT_EXTENSIONS, SUPPORTED_RENDERERS, Settings, SupportedLanguage, type TemplateConfiguration, type TemplateMatcher, _clearGlobalSettings, addToDevDependenciesIfNotPresent, adjustTemplate, builderNameToCoreBuilder, cliStoriesTargetPath, coerceSemver, compilerNameToCoreCompiler, compoDocPreviewPrefix, configureEslintPlugin, configureFlatConfig, copyTemplate, copyTemplateFiles, detect, detectBuilder, detectFrameworkPreset, detectLanguage, detectPnp, externalFrameworks, extractEslintInfo, findEslintFile, frameworkToDefaultBuilder, getBabelDependencies, getRendererDir, getStorybookVersionSpecifier, getVersionSafe, globalSettings, hasStorybookDependencies, installableProjectTypes, isNxProject, isStorybookInstantiated, normalizeExtends, promptForCompoDocs, readFileAsJson, suggestESLintPlugin, supportedTemplates, unsupportedTemplate, writeFileAsJson };
+export { ANGULAR_JSON_PATH, AngularJSON, type Builder, CommunityBuilder, CoreBuilder, CoreWebpackCompilers, type ExternalFramework, type NpmOptions, ProjectType, SUPPORTED_ESLINT_EXTENSIONS, SUPPORTED_RENDERERS, Settings, SupportedLanguage, type TemplateConfiguration, type TemplateMatcher, _clearGlobalSettings, addToDevDependenciesIfNotPresent, adjustTemplate, builderNameToCoreBuilder, cliStoriesTargetPath, coerceSemver, compilerNameToCoreCompiler, compoDocPreviewPrefix, configureEslintPlugin, configureFlatConfig, copyTemplate, copyTemplateFiles, detect, detectBuilder, detectFrameworkPreset, detectLanguage, detectPnp, externalFrameworks, extractEslintInfo, findEslintFile, frameworkToDefaultBuilder, getBabelDependencies, getRendererDir, getVersionSafe, globalSettings, hasStorybookDependencies, installableProjectTypes, isNxProject, isStorybookInstantiated, normalizeExtends, promptForCompoDocs, readFileAsJson, suggestESLintPlugin, supportedTemplates, unsupportedTemplate, writeFileAsJson };