storybook 9.0.0-beta.9 → 9.0.0-rc.1

package/dist/core-server/index.d.ts

@@ -1,7 +1,7 @@
 import { loadAllPresets } from 'storybook/internal/common';
 export { getPreviewBodyTemplate, getPreviewHeadTemplate } from 'storybook/internal/common';
 import * as storybook_internal_types from 'storybook/internal/types';
-import { CLIOptions, LoadOptions, BuilderOptions, StorybookConfigRaw, IndexInputStats, NormalizedStoriesSpecifier, Path, Indexer, DocsOptions, StoryIndexEntry, DocsIndexEntry, Tag, IndexEntry, StoryIndex, Options, NormalizedProjectAnnotations, ProjectAnnotations, ComposedStoryFn } from 'storybook/internal/types';
+import { CLIOptions, LoadOptions, BuilderOptions, StorybookConfigRaw, IndexInputStats, NormalizedStoriesSpecifier, Path as Path$1, Indexer, DocsOptions, StoryIndexEntry, DocsIndexEntry, Tag, IndexEntry, StoryIndex, Options, NormalizedProjectAnnotations, ProjectAnnotations, ComposedStoryFn } from 'storybook/internal/types';
 import { EventType } from 'storybook/internal/telemetry';
 import { Channel } from 'storybook/internal/channels';
 import { StoryId } from 'storybook/internal/csf';
@@ -84,7 +84,7 @@ type DocsCacheEntry = DocsIndexEntry;
 /** A `_.stories._` file will produce a list of stories and possibly a docs entry */
 type StoriesCacheEntry = {
     entries: (StoryIndexEntryWithExtra | DocsIndexEntry)[];
-    dependents: Path[];
+    dependents: Path$1[];
     type: 'stories';
 };
 type ErrorEntry = {
@@ -93,8 +93,8 @@ type ErrorEntry = {
 };
 type CacheEntry = false | StoriesCacheEntry | DocsCacheEntry | ErrorEntry;
 type StoryIndexGeneratorOptions = {
-    workingDir: Path;
-    configDir: Path;
+    workingDir: Path$1;
+    configDir: Path$1;
     indexers: Indexer[];
     docs: DocsOptions;
     build?: StorybookConfigRaw['build'];
@@ -131,24 +131,24 @@ declare class StoryIndexGenerator {
     constructor(specifiers: NormalizedStoriesSpecifier[], options: StoryIndexGeneratorOptions);
     initialize(): Promise<void>;
     /** Run the updater function over all the empty cache entries */
-    updateExtracted(updater: (specifier: NormalizedStoriesSpecifier, absolutePath: Path, existingEntry: CacheEntry) => Promise<CacheEntry>, overwrite?: boolean): Promise<void>;
-    isDocsMdx(absolutePath: Path): boolean;
+    updateExtracted(updater: (specifier: NormalizedStoriesSpecifier, absolutePath: Path$1, existingEntry: CacheEntry) => Promise<CacheEntry>, overwrite?: boolean): Promise<void>;
+    isDocsMdx(absolutePath: Path$1): boolean;
     ensureExtracted({ projectTags, }: {
         projectTags?: Tag[];
     }): Promise<{
         entries: (IndexEntry | ErrorEntry)[];
         stats: IndexStatsSummary;
     }>;
-    findDependencies(absoluteImports: Path[]): StoriesCacheEntry[];
+    findDependencies(absoluteImports: Path$1[]): StoriesCacheEntry[];
     /**
      * Try to find the component path from a raw import string and return it in the same format as
      * `importPath`. Respect tsconfig paths if available.
      *
      * If no such file exists, assume that the import is from a package and return the raw
      */
-    resolveComponentPath(rawComponentPath: Path, absolutePath: Path, matchPath: MatchPath | undefined): string;
-    extractStories(specifier: NormalizedStoriesSpecifier, absolutePath: Path, projectTags?: Tag[]): Promise<StoriesCacheEntry | DocsCacheEntry>;
-    extractDocs(specifier: NormalizedStoriesSpecifier, absolutePath: Path, projectTags?: Tag[]): Promise<false | DocsIndexEntry>;
+    resolveComponentPath(rawComponentPath: Path$1, absolutePath: Path$1, matchPath: MatchPath | undefined): string;
+    extractStories(specifier: NormalizedStoriesSpecifier, absolutePath: Path$1, projectTags?: Tag[]): Promise<StoriesCacheEntry | DocsCacheEntry>;
+    extractDocs(specifier: NormalizedStoriesSpecifier, absolutePath: Path$1, projectTags?: Tag[]): Promise<false | DocsIndexEntry>;
     chooseDuplicate(firstEntry: IndexEntry, secondEntry: IndexEntry, projectTags: Tag[]): IndexEntry;
     sortStories(entries: StoryIndex['entries'], storySortParameter: any): Promise<Record<string, IndexEntry>>;
     getIndex(): Promise<StoryIndex>;
@@ -157,7 +157,7 @@ declare class StoryIndexGenerator {
         stats: IndexStatsSummary;
     }>;
     invalidateAll(): void;
-    invalidate(specifier: NormalizedStoriesSpecifier, importPath: Path, removed: boolean): void;
+    invalidate(specifier: NormalizedStoriesSpecifier, importPath: Path$1, removed: boolean): void;
     getPreviewCode(): Promise<string | undefined>;
     getProjectTags(previewCode?: string): string[];
     storyFileNames(): string[];
@@ -491,6 +491,507 @@ type StatusStoreByTypeId = StatusStore & {
     typeId: StatusTypeId;
 };
 
+/**
+ * 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;
+}
+
 type TestProviderState = 'test-provider-state:pending' | 'test-provider-state:running' | 'test-provider-state:succeeded' | 'test-provider-state:crashed';
 type TestProviderId = string;
 type TestProviderStateByProviderId = Record<TestProviderId, TestProviderState>;

package/dist/core-server/index.js

@@ -35134,16 +35134,16 @@ var j1 = /* @__PURE__ */ s((e, t, r) => e.startsWith(".") ? Ze(qs(r, Ua(Va(q1(t)
         tags: k
       };
     });
-    if (f.some((g) => g.tags.includes(Nn)) && this.options.build?.test?.disableAutoDocs !== !0) {
-      let g = this.options.docs.defaultName ?? "Docs", { metaId: b } = l[0], { title: D } = f[0], v = qh(b ?? D, g), S = jh(...i, ...l[0].tags ??
+    if (f.some((g) => g.tags.includes(Nn)) && !!this.options.docs && this.options.build?.test?.disableAutoDocs !== !0) {
+      let b = this.options.docs?.defaultName ?? "Docs", { metaId: D } = l[0], { title: v } = f[0], S = qh(D ?? v, b), k = jh(...i, ...l[0].tags ??
       []);
       f.unshift({
-        id: v,
-        title: D,
-        name: g,
+        id: S,
+        title: v,
+        name: b,
         importPath: o,
         type: "docs",
-        tags: S,
+        tags: k,
         storiesImports: []
       });
     }
@@ -35193,7 +35193,7 @@ var j1 = /* @__PURE__ */ s((e, t, r) => e.startsWith(".") ? Ze(qs(r, Ua(Va(q1(t)
         m,
         "makeTitle created an undefined title. This happens when a specifier's doesn't have any matches in its fileName"
       );
-      let g = this.options.docs.defaultName ?? "Docs", b = c.name || (d ? Kg(a, d.importPath, g) : g), D = qh(d?.extra.metaId || m, b), v = jh(
+      let g = this.options.docs?.defaultName ?? "Docs", b = c.name || (d ? Kg(a, d.importPath, g) : g), D = qh(d?.extra.metaId || m, b), v = jh(
         ...i,
         ...d?.tags ?? [],
         ...c.metaTags ?? [],
@@ -35229,8 +35229,8 @@ is: ${Vh.default.yellow(
         r.importPath
       ]);
     if (o.type === "story") {
-      let l = Ui(a) ? "component docs page" : "automatically generated docs page";
-      throw o.name === this.options.docs.defaultName ? new Cr(
+      let l = Ui(a) ? "component docs page" : "automatically generated docs page", c = this.options.docs?.defaultName ?? "Docs";
+      throw o.name === c ? new Cr(
         `You have a story for ${o.title} with the same name as your default docs entry name (${o.name}), so the docs page is being dropped. \
 Consider changing the story name.`,
         [t.importPath, r.importPath]
@@ -35812,7 +35812,7 @@ async function IC(e) {
     o.apply("staticDirs"),
     o.apply("experimental_indexers", []),
     o.apply("stories"),
-    o.apply("docs", {})
+    o.apply("docs")
   ]), D = {
     ...e,
     presets: o,
@@ -36672,7 +36672,7 @@ async function JS(e, t, r) {
   let i = process.cwd(), n = t.configDir, o = {
     configDir: n,
     workingDir: i
-  }, a = t.presets.apply("stories"), u = t.presets.apply("experimental_indexers", []), l = t.presets.apply("docs", {}), c = Zz(await a, o), p = new Qr(
+  }, a = t.presets.apply("stories"), u = t.presets.apply("experimental_indexers", []), l = t.presets.apply("docs"), c = Zz(await a, o), p = new Qr(
   c, {
     ...o,
     indexers: await u,
@@ -38131,7 +38131,7 @@ var BX = /* @__PURE__ */ s(async (e) => {
   let { presets: t } = await Zm(e), [r, i, n] = await Promise.all([
     t.apply("experimental_indexers", []),
     t.apply("stories", []),
-    t.apply("docs", {})
+    t.apply("docs")
   ]), { configDir: o } = e, a = process.cwd(), u = {
     configDir: o,
     workingDir: a