storybook 10.1.0-alpha.12 → 10.1.0-alpha.13

package/dist/cli/index.d.ts

@@ -1,105 +1,11 @@
-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 { JsPackageManager as JsPackageManager$1, PackageJson } from 'storybook/internal/common';
+import { SupportedFramework as SupportedFramework$1, SupportedRenderer, SupportedLanguage, Feature, PackageJson as PackageJson$1, NormalizedProjectAnnotations, ProjectAnnotations, ComposedStoryFn } from 'storybook/internal/types';
 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 = {
-    name: SupportedFrameworks;
-    packageName?: string;
-    frameworks?: string[];
-    renderer?: string;
-};
-declare const externalFrameworks: ExternalFramework[];
-declare const SUPPORTED_RENDERERS: SupportedRenderers[];
-declare enum ProjectType {
-    UNDETECTED = "UNDETECTED",
-    UNSUPPORTED = "UNSUPPORTED",
-    REACT = "REACT",
-    REACT_SCRIPTS = "REACT_SCRIPTS",
-    REACT_NATIVE = "REACT_NATIVE",
-    REACT_NATIVE_WEB = "REACT_NATIVE_WEB",
-    REACT_NATIVE_AND_RNW = "REACT_NATIVE_AND_RNW",
-    REACT_PROJECT = "REACT_PROJECT",
-    WEBPACK_REACT = "WEBPACK_REACT",
-    NEXTJS = "NEXTJS",
-    VUE3 = "VUE3",
-    NUXT = "NUXT",
-    ANGULAR = "ANGULAR",
-    EMBER = "EMBER",
-    WEB_COMPONENTS = "WEB_COMPONENTS",
-    HTML = "HTML",
-    QWIK = "QWIK",
-    PREACT = "PREACT",
-    SVELTE = "SVELTE",
-    SVELTEKIT = "SVELTEKIT",
-    SERVER = "SERVER",
-    NX = "NX",
-    SOLID = "SOLID"
-}
-declare enum CoreBuilder {
-    Webpack5 = "webpack5",
-    Vite = "vite"
-}
-declare enum CoreWebpackCompilers {
-    Babel = "babel",
-    SWC = "swc"
-}
-declare enum CommunityBuilder {
-    Rsbuild = "rsbuild"
-}
-declare const compilerNameToCoreCompiler: Record<string, CoreWebpackCompilers>;
-declare const builderNameToCoreBuilder: Record<string, CoreBuilder>;
-type Builder = CoreBuilder | (string & {});
-declare enum SupportedLanguage {
-    JAVASCRIPT = "javascript",
-    TYPESCRIPT = "typescript"
-}
-type TemplateMatcher = {
-    files?: boolean[];
-    dependencies?: boolean[];
-    peerDependencies?: boolean[];
-};
-type TemplateConfiguration = {
-    preset: ProjectType;
-    /** Will be checked both against dependencies and devDependencies */
-    dependencies?: string[] | {
-        [dependency: string]: (version: string) => boolean;
-    };
-    peerDependencies?: string[] | {
-        [dependency: string]: (version: string) => boolean;
-    };
-    files?: string[];
-    matcherFunction: (matcher: TemplateMatcher) => boolean;
-};
-/**
- * Configuration to match a storybook preset template.
- *
- * This has to be an array sorted in order of specificity/priority. Reason: both REACT and
- * WEBPACK_REACT have react as dependency, therefore WEBPACK_REACT has to come first, as it's more
- * specific.
- */
-declare const supportedTemplates: TemplateConfiguration[];
-declare const unsupportedTemplate: TemplateConfiguration;
-declare const installableProjectTypes: string[];
-
-declare function detectFrameworkPreset(packageJson?: PackageJsonWithMaybeDeps): ProjectType | null;
-/**
- * Attempts to detect which builder to use, by searching for a vite config file or webpack
- * installation. If neither are found it will choose the default builder based on the project type.
- *
- * @returns CoreBuilder
- */
-declare function detectBuilder(packageManager: JsPackageManager$1, projectType: ProjectType): Promise<any>;
-declare function isStorybookInstantiated(configDir?: string): boolean;
 declare function detectPnp(): Promise<boolean>;
-declare function detectLanguage(packageManager: JsPackageManager$1): Promise<SupportedLanguage>;
-declare function detect(packageManager: JsPackageManager$1, options?: {
-    force?: boolean;
-    html?: boolean;
-}): Promise<ProjectType | null>;
 
 declare function readFileAsJson(jsonPath: string, allowComments?: boolean): any;
 declare const writeFileAsJson: (jsonPath: string, content: unknown) => boolean;
@@ -129,13 +35,12 @@ declare function addToDevDependenciesIfNotPresent(packageJson: PackageJson, name
 declare function copyTemplate(templateRoot: string, destination?: string): void;
 type CopyTemplateFilesOptions = {
     packageManager: JsPackageManager$1;
-    templateLocation: SupportedFrameworks | SupportedRenderers;
+    templateLocation: SupportedFramework$1 | SupportedRenderer;
     language: SupportedLanguage;
     commonAssetsDir?: string;
     destination?: string;
-    features: string[];
+    features: Set<Feature>;
 };
-declare const frameworkToDefaultBuilder: Record<SupportedFrameworks, CoreBuilder | CommunityBuilder>;
 /**
  * Return the installed version of a package, or the coerced version specifier from package.json if
  * it's a dependency but not installed (e.g. in a fresh project)
@@ -144,13 +49,10 @@ 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 isNxProject(): Promise<string | undefined>;
 declare function coerceSemver(version: string): semver.SemVer;
 declare function hasStorybookDependencies(packageManager: JsPackageManager$1): boolean;
 
 declare const ANGULAR_JSON_PATH = "angular.json";
-declare const compoDocPreviewPrefix: string;
-declare const promptForCompoDocs: () => Promise<boolean>;
 declare class AngularJSON {
     json: {
         projects: Record<string, {
@@ -177,7 +79,7 @@ declare class AngularJSON {
         projectType: string;
         architect: Record<string, any>;
     };
-    getProjectName(): Promise<any>;
+    getProjectName(): Promise<string>;
     addStorybookEntries({ angularProjectName, storybookFolder, useCompodoc, root, }: {
         angularProjectName: string;
         storybookFolder: string;
@@ -187,7 +89,32 @@ declare class AngularJSON {
     write(): void;
 }
 
-declare function getRendererDir(packageManager: JsPackageManager$1, renderer: SupportedFrameworks | SupportedRenderers): Promise<string>;
+declare function getRendererDir(packageManager: JsPackageManager$1, renderer: SupportedFramework$1 | SupportedRenderer): Promise<string>;
+
+declare enum ProjectType {
+    ANGULAR = "angular",
+    EMBER = "ember",
+    HTML = "html",
+    NEXTJS = "nextjs",
+    NUXT = "nuxt",
+    NX = "nx",
+    PREACT = "preact",
+    QWIK = "qwik",
+    REACT = "react",
+    REACT_NATIVE = "react_native",
+    REACT_NATIVE_AND_RNW = "react_native_and_rnw",
+    REACT_NATIVE_WEB = "react_native_web",
+    REACT_PROJECT = "react_project",
+    REACT_SCRIPTS = "react_scripts",
+    SERVER = "server",
+    SOLID = "solid",
+    SVELTE = "svelte",
+    SVELTEKIT = "sveltekit",
+    UNDETECTED = "undetected",
+    UNSUPPORTED = "unsupported",
+    VUE3 = "vue3",
+    WEB_COMPONENTS = "web_components"
+}
 
 type StdioOption =
 	| 'pipe'
@@ -664,6 +591,14 @@ type ExecaChildProcess<StdoutStderrType extends StdoutStderrAll = string> = Chil
 ExecaChildPromise<StdoutStderrType> &
 Promise<ExecaReturnValue<StdoutStderrType>>;
 
+type ExecuteCommandOptions = CommonOptions<'utf8'> & {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    ignoreError?: boolean;
+    env?: Record<string, any>;
+};
+
 type PackageJsonWithDepsAndDevDeps = PackageJson$1 & Required<Pick<PackageJson$1, 'dependencies' | 'devDependencies'>>;
 
 type PackageMetadata = {
@@ -678,7 +613,13 @@ type InstallationMetadata = {
     dedupeCommand: string;
 };
 
-type PackageManagerName = 'npm' | 'yarn1' | 'yarn2' | 'pnpm' | 'bun';
+declare enum PackageManagerName {
+    NPM = "npm",
+    YARN1 = "yarn",
+    YARN2 = "yarn2",
+    PNPM = "pnpm",
+    BUN = "bun"
+}
 interface JsPackageManagerOptions {
     cwd?: string;
     configDir?: string;
@@ -707,14 +648,11 @@ declare abstract class JsPackageManager {
     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>;
+    /** Cache for package.json files to avoid repeated file system calls. */
+    static readonly packageJsonCache: Map<string, PackageJsonWithDepsAndDevDeps>;
     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): Promise<PackageJson$1 | null>;
     isStorybookInMonorepo(): boolean;
@@ -846,33 +784,14 @@ declare abstract class JsPackageManager {
     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 runPackageCommand(options: Omit<ExecuteCommandOptions, 'command'> & {
+        args: string[];
+    }): ExecaChildProcess;
     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>;
@@ -1868,4 +1787,644 @@ 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, getVersionSafe, globalSettings, hasStorybookDependencies, installableProjectTypes, isNxProject, isStorybookInstantiated, normalizeExtends, promptForCompoDocs, readFileAsJson, suggestESLintPlugin, supportedTemplates, unsupportedTemplate, writeFileAsJson };
+/**
+ * Actions represent the type of change to a location value.
+ */
+declare enum Action {
+    /**
+     * A POP indicates a change to an arbitrary index in the history stack, such
+     * as a back or forward navigation. It does not describe the direction of the
+     * navigation, only that the current index changed.
+     *
+     * Note: This is the default action for newly created history objects.
+     */
+    Pop = "POP",
+    /**
+     * A PUSH indicates a new entry being added to the history stack, such as when
+     * a link is clicked and a new page loads. When this happens, all subsequent
+     * entries in the stack are lost.
+     */
+    Push = "PUSH",
+    /**
+     * A REPLACE indicates the entry at the current index in the history stack
+     * being replaced by a new one.
+     */
+    Replace = "REPLACE"
+}
+/**
+ * The pathname, search, and hash values of a URL.
+ */
+interface Path {
+    /**
+     * A URL pathname, beginning with a /.
+     */
+    pathname: string;
+    /**
+     * A URL search string, beginning with a ?.
+     */
+    search: string;
+    /**
+     * A URL fragment identifier, beginning with a #.
+     */
+    hash: string;
+}
+/**
+ * An entry in a history stack. A location contains information about the
+ * URL path, as well as possibly some arbitrary state and a key.
+ */
+interface Location extends Path {
+    /**
+     * A value of arbitrary data associated with this location.
+     */
+    state: any;
+    /**
+     * A unique string associated with this location. May be used to safely store
+     * and retrieve data in some other storage API, like `localStorage`.
+     *
+     * Note: This value is always "default" on the initial location.
+     */
+    key: string;
+}
+
+/**
+ * Map of routeId -> data returned from a loader/action/error
+ */
+interface RouteData {
+    [routeId: string]: any;
+}
+declare enum ResultType {
+    data = "data",
+    deferred = "deferred",
+    redirect = "redirect",
+    error = "error"
+}
+/**
+ * Successful result from a loader or action
+ */
+interface SuccessResult {
+    type: ResultType.data;
+    data: any;
+    statusCode?: number;
+    headers?: Headers;
+}
+/**
+ * Successful defer() result from a loader or action
+ */
+interface DeferredResult {
+    type: ResultType.deferred;
+    deferredData: DeferredData;
+    statusCode?: number;
+    headers?: Headers;
+}
+/**
+ * Redirect result from a loader or action
+ */
+interface RedirectResult {
+    type: ResultType.redirect;
+    status: number;
+    location: string;
+    revalidate: boolean;
+    reloadDocument?: boolean;
+}
+/**
+ * Unsuccessful result from a loader or action
+ */
+interface ErrorResult {
+    type: ResultType.error;
+    error: any;
+    headers?: Headers;
+}
+/**
+ * Result from a loader or action - potentially successful or unsuccessful
+ */
+type DataResult = SuccessResult | DeferredResult | RedirectResult | ErrorResult;
+type LowerCaseFormMethod = "get" | "post" | "put" | "patch" | "delete";
+type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;
+/**
+ * Active navigation/fetcher form methods are exposed in lowercase on the
+ * RouterState
+ */
+type FormMethod = LowerCaseFormMethod;
+/**
+ * In v7, active navigation/fetcher form methods are exposed in uppercase on the
+ * RouterState.  This is to align with the normalization done via fetch().
+ */
+type V7_FormMethod = UpperCaseFormMethod;
+type FormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "application/json" | "text/plain";
+type JsonObject = {
+    [Key in string]: JsonValue;
+} & {
+    [Key in string]?: JsonValue | undefined;
+};
+type JsonArray = JsonValue[] | readonly JsonValue[];
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+/**
+ * @private
+ * Internal interface to pass around for action submissions, not intended for
+ * external consumption
+ */
+type Submission = {
+    formMethod: FormMethod | V7_FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: FormData;
+    json: undefined;
+    text: undefined;
+} | {
+    formMethod: FormMethod | V7_FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: undefined;
+    json: JsonValue;
+    text: undefined;
+} | {
+    formMethod: FormMethod | V7_FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: undefined;
+    json: undefined;
+    text: string;
+};
+/**
+ * @private
+ * Arguments passed to route loader/action functions.  Same for now but we keep
+ * this as a private implementation detail in case they diverge in the future.
+ */
+interface DataFunctionArgs {
+    request: Request;
+    params: Params;
+    context?: any;
+}
+/**
+ * Arguments passed to loader functions
+ */
+interface LoaderFunctionArgs extends DataFunctionArgs {
+}
+/**
+ * Arguments passed to action functions
+ */
+interface ActionFunctionArgs extends DataFunctionArgs {
+}
+/**
+ * Loaders and actions can return anything except `undefined` (`null` is a
+ * valid return value if there is no data to return).  Responses are preferred
+ * and will ease any future migration to Remix
+ */
+type DataFunctionValue = Response | NonNullable<unknown> | null;
+/**
+ * Route loader function signature
+ */
+interface LoaderFunction {
+    (args: LoaderFunctionArgs): Promise<DataFunctionValue> | DataFunctionValue;
+}
+/**
+ * Route action function signature
+ */
+interface ActionFunction {
+    (args: ActionFunctionArgs): Promise<DataFunctionValue> | DataFunctionValue;
+}
+/**
+ * Route shouldRevalidate function signature.  This runs after any submission
+ * (navigation or fetcher), so we flatten the navigation/fetcher submission
+ * onto the arguments.  It shouldn't matter whether it came from a navigation
+ * or a fetcher, what really matters is the URLs and the formData since loaders
+ * have to re-run based on the data models that were potentially mutated.
+ */
+interface ShouldRevalidateFunction {
+    (args: {
+        currentUrl: URL;
+        currentParams: AgnosticDataRouteMatch["params"];
+        nextUrl: URL;
+        nextParams: AgnosticDataRouteMatch["params"];
+        formMethod?: Submission["formMethod"];
+        formAction?: Submission["formAction"];
+        formEncType?: Submission["formEncType"];
+        text?: Submission["text"];
+        formData?: Submission["formData"];
+        json?: Submission["json"];
+        actionResult?: DataResult;
+        defaultShouldRevalidate: boolean;
+    }): boolean;
+}
+/**
+ * Keys we cannot change from within a lazy() function. We spread all other keys
+ * onto the route. Either they're meaningful to the router, or they'll get
+ * ignored.
+ */
+type ImmutableRouteKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
+type RequireOne<T, Key = keyof T> = Exclude<{
+    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;
+}[keyof T], undefined>;
+/**
+ * lazy() function to load a route definition, which can add non-matching
+ * related properties to a route
+ */
+interface LazyRouteFunction<R extends AgnosticRouteObject> {
+    (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;
+}
+/**
+ * Base RouteObject with common props shared by all types of routes
+ */
+type AgnosticBaseRouteObject = {
+    caseSensitive?: boolean;
+    path?: string;
+    id?: string;
+    loader?: LoaderFunction;
+    action?: ActionFunction;
+    hasErrorBoundary?: boolean;
+    shouldRevalidate?: ShouldRevalidateFunction;
+    handle?: any;
+    lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;
+};
+/**
+ * Index routes must not have children
+ */
+type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {
+    children?: undefined;
+    index: true;
+};
+/**
+ * Non-index routes may have children, but cannot have index
+ */
+type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {
+    children?: AgnosticRouteObject[];
+    index?: false;
+};
+/**
+ * A route object represents a logical route, with (optionally) its child
+ * routes organized in a tree-like structure.
+ */
+type AgnosticRouteObject = AgnosticIndexRouteObject | AgnosticNonIndexRouteObject;
+type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {
+    id: string;
+};
+type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {
+    children?: AgnosticDataRouteObject[];
+    id: string;
+};
+/**
+ * A data route object, which is just a RouteObject with a required unique ID
+ */
+type AgnosticDataRouteObject = AgnosticDataIndexRouteObject | AgnosticDataNonIndexRouteObject;
+/**
+ * The parameters that were parsed from the URL path.
+ */
+type Params<Key extends string = string> = {
+    readonly [key in Key]: string | undefined;
+};
+/**
+ * A RouteMatch contains info about how a route matched a URL.
+ */
+interface AgnosticRouteMatch<ParamKey extends string = string, RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject> {
+    /**
+     * The names and values of dynamic parameters in the URL.
+     */
+    params: Params<ParamKey>;
+    /**
+     * The portion of the URL pathname that was matched.
+     */
+    pathname: string;
+    /**
+     * The portion of the URL pathname that was matched before child routes.
+     */
+    pathnameBase: string;
+    /**
+     * The route object that was used to match.
+     */
+    route: RouteObjectType;
+}
+interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
+}
+declare class DeferredData {
+    private pendingKeysSet;
+    private controller;
+    private abortPromise;
+    private unlistenAbortSignal;
+    private subscribers;
+    data: Record<string, unknown>;
+    init?: ResponseInit;
+    deferredKeys: string[];
+    constructor(data: Record<string, unknown>, responseInit?: ResponseInit);
+    private trackPromise;
+    private onSettle;
+    private emit;
+    subscribe(fn: (aborted: boolean, settledKey?: string) => void): () => boolean;
+    cancel(): void;
+    resolveData(signal: AbortSignal): Promise<boolean>;
+    get done(): boolean;
+    get unwrappedData(): {};
+    get pendingKeys(): string[];
+}
+
+/**
+ * State maintained internally by the router.  During a navigation, all states
+ * reflect the the "old" location unless otherwise noted.
+ */
+interface RouterState {
+    /**
+     * The action of the most recent navigation
+     */
+    historyAction: Action;
+    /**
+     * The current location reflected by the router
+     */
+    location: Location;
+    /**
+     * The current set of route matches
+     */
+    matches: AgnosticDataRouteMatch[];
+    /**
+     * Tracks whether we've completed our initial data load
+     */
+    initialized: boolean;
+    /**
+     * Current scroll position we should start at for a new view
+     *  - number -> scroll position to restore to
+     *  - false -> do not restore scroll at all (used during submissions)
+     *  - null -> don't have a saved position, scroll to hash or top of page
+     */
+    restoreScrollPosition: number | false | null;
+    /**
+     * Indicate whether this navigation should skip resetting the scroll position
+     * if we are unable to restore the scroll position
+     */
+    preventScrollReset: boolean;
+    /**
+     * Tracks the state of the current navigation
+     */
+    navigation: Navigation;
+    /**
+     * Tracks any in-progress revalidations
+     */
+    revalidation: RevalidationState;
+    /**
+     * Data from the loaders for the current matches
+     */
+    loaderData: RouteData;
+    /**
+     * Data from the action for the current matches
+     */
+    actionData: RouteData | null;
+    /**
+     * Errors caught from loaders for the current matches
+     */
+    errors: RouteData | null;
+    /**
+     * Map of current fetchers
+     */
+    fetchers: Map<string, Fetcher>;
+    /**
+     * Map of current blockers
+     */
+    blockers: Map<string, Blocker>;
+}
+/**
+ * Data that can be passed into hydrate a Router from SSR
+ */
+type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "errors">>;
+/**
+ * Potential states for state.navigation
+ */
+type NavigationStates = {
+    Idle: {
+        state: "idle";
+        location: undefined;
+        formMethod: undefined;
+        formAction: undefined;
+        formEncType: undefined;
+        formData: undefined;
+        json: undefined;
+        text: undefined;
+    };
+    Loading: {
+        state: "loading";
+        location: Location;
+        formMethod: Submission["formMethod"] | undefined;
+        formAction: Submission["formAction"] | undefined;
+        formEncType: Submission["formEncType"] | undefined;
+        formData: Submission["formData"] | undefined;
+        json: Submission["json"] | undefined;
+        text: Submission["text"] | undefined;
+    };
+    Submitting: {
+        state: "submitting";
+        location: Location;
+        formMethod: Submission["formMethod"];
+        formAction: Submission["formAction"];
+        formEncType: Submission["formEncType"];
+        formData: Submission["formData"];
+        json: Submission["json"];
+        text: Submission["text"];
+    };
+};
+type Navigation = NavigationStates[keyof NavigationStates];
+type RevalidationState = "idle" | "loading";
+/**
+ * Potential states for fetchers
+ */
+type FetcherStates<TData = any> = {
+    Idle: {
+        state: "idle";
+        formMethod: undefined;
+        formAction: undefined;
+        formEncType: undefined;
+        text: undefined;
+        formData: undefined;
+        json: undefined;
+        data: TData | undefined;
+        " _hasFetcherDoneAnything "?: boolean;
+    };
+    Loading: {
+        state: "loading";
+        formMethod: Submission["formMethod"] | undefined;
+        formAction: Submission["formAction"] | undefined;
+        formEncType: Submission["formEncType"] | undefined;
+        text: Submission["text"] | undefined;
+        formData: Submission["formData"] | undefined;
+        json: Submission["json"] | undefined;
+        data: TData | undefined;
+        " _hasFetcherDoneAnything "?: boolean;
+    };
+    Submitting: {
+        state: "submitting";
+        formMethod: Submission["formMethod"];
+        formAction: Submission["formAction"];
+        formEncType: Submission["formEncType"];
+        text: Submission["text"];
+        formData: Submission["formData"];
+        json: Submission["json"];
+        data: TData | undefined;
+        " _hasFetcherDoneAnything "?: boolean;
+    };
+};
+type Fetcher<TData = any> = FetcherStates<TData>[keyof FetcherStates<TData>];
+interface BlockerBlocked {
+    state: "blocked";
+    reset(): void;
+    proceed(): void;
+    location: Location;
+}
+interface BlockerUnblocked {
+    state: "unblocked";
+    reset: undefined;
+    proceed: undefined;
+    location: undefined;
+}
+interface BlockerProceeding {
+    state: "proceeding";
+    reset: undefined;
+    proceed: undefined;
+    location: Location;
+}
+type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;
+
+/**
+ * NOTE: If you refactor this to split up the modules into separate files,
+ * you'll need to update the rollup config for react-router-dom-v5-compat.
+ */
+
+declare global {
+    var __staticRouterHydrationData: HydrationState | undefined;
+}
+
+declare global {
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare enum SupportedBuilder {
+    WEBPACK5 = "webpack5",
+    VITE = "vite",
+    RSBUILD = "rsbuild"
+}
+
+declare enum SupportedFramework {
+    ANGULAR = "angular",
+    EMBER = "ember",
+    HTML_VITE = "html-vite",
+    NEXTJS = "nextjs",
+    NEXTJS_VITE = "nextjs-vite",
+    PREACT_VITE = "preact-vite",
+    REACT_NATIVE_WEB_VITE = "react-native-web-vite",
+    REACT_VITE = "react-vite",
+    REACT_WEBPACK5 = "react-webpack5",
+    SERVER_WEBPACK5 = "server-webpack5",
+    SVELTE_VITE = "svelte-vite",
+    SVELTEKIT = "sveltekit",
+    VUE3_VITE = "vue3-vite",
+    WEB_COMPONENTS_VITE = "web-components-vite",
+    HTML_RSBUILD = "html-rsbuild",
+    NUXT = "nuxt",
+    QWIK = "qwik",
+    REACT_RSBUILD = "react-rsbuild",
+    SOLID = "solid",
+    VUE3_RSBUILD = "vue3-rsbuild",
+    WEB_COMPONENTS_RSBUILD = "web-components-rsbuild"
+}
+
+declare global {
+    var globalProjectAnnotations: NormalizedProjectAnnotations<any>;
+    var defaultProjectAnnotations: ProjectAnnotations<any>;
+}
+type WrappedStoryRef = {
+    __pw_type: 'jsx';
+    props: Record<string, any>;
+} | {
+    __pw_type: 'importRef';
+};
+type UnwrappedJSXStoryRef = {
+    __pw_type: 'jsx';
+    type: UnwrappedImportStoryRef;
+};
+type UnwrappedImportStoryRef = ComposedStoryFn;
+declare global {
+    function __pwUnwrapObject(storyRef: WrappedStoryRef): Promise<UnwrappedJSXStoryRef | UnwrappedImportStoryRef>;
+}
+
+type Result = {
+    compatible: boolean;
+    reasons?: string[];
+};
+interface AddonVitestCompatibilityOptions {
+    packageManager: JsPackageManager$1;
+    builder?: SupportedBuilder;
+    framework?: SupportedFramework | null;
+    projectRoot?: string;
+}
+/**
+ * Centralized service for @storybook/addon-vitest dependency collection and compatibility
+ * validation
+ *
+ * This service consolidates logic from:
+ *
+ * - Code/addons/vitest/src/postinstall.ts
+ * - Code/lib/create-storybook/src/addon-dependencies/addon-vitest.ts
+ * - Code/lib/create-storybook/src/services/FeatureCompatibilityService.ts
+ */
+declare class AddonVitestService {
+    readonly supportedFrameworks: SupportedFramework[];
+    /**
+     * Collect all dependencies needed for @storybook/addon-vitest
+     *
+     * Returns versioned package strings ready for installation:
+     *
+     * - Base packages: vitest, @vitest/browser, playwright
+     * - Next.js specific: @storybook/nextjs-vite
+     * - Coverage reporter: @vitest/coverage-v8
+     */
+    collectDependencies(packageManager: JsPackageManager$1): Promise<string[]>;
+    /**
+     * Install Playwright browser binaries for @storybook/addon-vitest
+     *
+     * Installs Chromium with dependencies via `npx playwright install chromium --with-deps`
+     *
+     * @param packageManager - The package manager to use for installation
+     * @param prompt - The prompt instance for displaying progress
+     * @param logger - The logger instance for displaying messages
+     * @param options - Installation options
+     * @returns Array of error messages if installation fails
+     */
+    installPlaywright(packageManager: JsPackageManager$1, options?: {
+        yes?: boolean;
+    }): Promise<{
+        errors: string[];
+    }>;
+    /**
+     * Validate full compatibility for @storybook/addon-vitest
+     *
+     * Checks:
+     *
+     * - Webpack configuration compatibility
+     * - Builder compatibility (Vite or Next.js)
+     * - Renderer/framework support
+     * - Vitest version (>=3.0.0)
+     * - MSW version (>=2.0.0 if installed)
+     * - Next.js installation (if using @storybook/nextjs)
+     * - Vitest config files (if configDir provided)
+     */
+    validateCompatibility(options: AddonVitestCompatibilityOptions): Promise<Result>;
+    /**
+     * Validate package versions for addon-vitest compatibility Public method to allow early
+     * validation before framework detection
+     */
+    validatePackageVersions(packageManager: JsPackageManager$1): Promise<Result>;
+    /**
+     * Validate vitest config files for addon compatibility
+     *
+     * Public method that can be used by both postinstall and create-storybook flows
+     */
+    validateConfigFiles(directory: string): Promise<Result>;
+    /** Validate workspace config file structure */
+    private isValidWorkspaceConfigFile;
+    /** Validate Vitest config file structure */
+    private isValidVitestConfig;
+    private isWorkspaceConfigArray;
+    private isDefineWorkspaceExpression;
+    private isDefineConfigExpression;
+    private isMergeConfigExpression;
+    private isSafeToExtendWorkspace;
+}
+
+export { ANGULAR_JSON_PATH, type AddonVitestCompatibilityOptions, AddonVitestService, AngularJSON, type NpmOptions, ProjectType, SUPPORTED_ESLINT_EXTENSIONS, Settings, _clearGlobalSettings, addToDevDependenciesIfNotPresent, adjustTemplate, cliStoriesTargetPath, coerceSemver, configureEslintPlugin, configureFlatConfig, copyTemplate, copyTemplateFiles, detectPnp, extractEslintInfo, findEslintFile, getBabelDependencies, getRendererDir, getVersionSafe, globalSettings, hasStorybookDependencies, normalizeExtends, readFileAsJson, suggestESLintPlugin, writeFileAsJson };