@storybook/preview-api 7.0.0-alpha.54

package/README.md

@@ -0,0 +1,13 @@
+# Preview API
+
+TODO write proper documentation of this package
+
+# "Sub packages" README documents
+
+This package used to be multiple packages (they have been combined into this one):
+
+- `@storybook/addons` [read (old) docs](./README-addons.md)
+- `@storybook/client-api` [read (old) docs](./README-client-api.md)
+- `@storybook/core-client` [read (old) docs](./README-core-client.md)
+- `@storybook/preview-web` [read (old) docs](./README-preview-web.md)
+- `@storybook/store` [read (old) docs](./README-store.md)

package/dist/ClientApi-dce2f8f2.d.ts

@@ -0,0 +1,65 @@
+import * as _storybook_types from '@storybook/types';
+import { Renderer, Store_NormalizedProjectAnnotations, StoryId, Addon_IndexEntry, ComponentId, Path, Store_ModuleExports, DecoratorFunction, Parameters, LoaderFunction, Args, ArgTypes, ArgsEnhancer, ArgTypesEnhancer, StepRunner, Store_ModuleImportFn, Globals, GlobalTypes, Addon_StoryApi } from '@storybook/types';
+import { S as StoryStore } from './StoryStore-8f9ab1c2.js';
+
+declare class StoryStoreFacade<TRenderer extends Renderer> {
+    projectAnnotations: Store_NormalizedProjectAnnotations<TRenderer>;
+    entries: Record<StoryId, Addon_IndexEntry & {
+        componentId?: ComponentId;
+    }>;
+    csfExports: Record<Path, Store_ModuleExports>;
+    constructor();
+    importFn(path: Path): Promise<Store_ModuleExports>;
+    getStoryIndex(store: StoryStore<TRenderer>): {
+        v: number;
+        entries: Record<string, Addon_IndexEntry>;
+    };
+    clearFilenameExports(fileName: Path): void;
+    addStoriesFromExports(fileName: Path, fileExports: Store_ModuleExports): void;
+}
+
+declare let singleton: ClientApi<Renderer>;
+declare const addDecorator: (decorator: DecoratorFunction<Renderer>) => void;
+declare const addParameters: (parameters: Parameters) => void;
+declare const addLoader: (loader: LoaderFunction<Renderer>) => void;
+declare const addArgs: (args: Args) => void;
+declare const addArgTypes: (argTypes: ArgTypes) => void;
+declare const addArgsEnhancer: (enhancer: ArgsEnhancer<Renderer>) => void;
+declare const addArgTypesEnhancer: (enhancer: ArgTypesEnhancer<Renderer>) => void;
+declare const addStepRunner: (stepRunner: StepRunner) => void;
+declare const setGlobalRender: (render: (typeof singleton)['facade']['projectAnnotations']['render']) => void;
+declare class ClientApi<TRenderer extends Renderer> {
+    facade: StoryStoreFacade<TRenderer>;
+    storyStore?: StoryStore<TRenderer>;
+    private addons;
+    onImportFnChanged?: ({ importFn }: {
+        importFn: Store_ModuleImportFn;
+    }) => void;
+    private lastFileName;
+    constructor({ storyStore }?: {
+        storyStore?: StoryStore<TRenderer>;
+    });
+    importFn(path: Path): Promise<Store_ModuleExports>;
+    getStoryIndex(): {
+        v: number;
+        entries: Record<string, _storybook_types.Addon_IndexEntry>;
+    };
+    addDecorator: (decorator: DecoratorFunction<TRenderer>) => void;
+    addParameters: ({ globals, globalTypes, ...parameters }: Parameters & {
+        globals?: Globals | undefined;
+        globalTypes?: GlobalTypes | undefined;
+    }) => void;
+    addStepRunner: (stepRunner: StepRunner) => void;
+    addLoader: (loader: LoaderFunction<TRenderer>) => void;
+    addArgs: (args: Args) => void;
+    addArgTypes: (argTypes: ArgTypes) => void;
+    addArgsEnhancer: (enhancer: ArgsEnhancer<TRenderer>) => void;
+    addArgTypesEnhancer: (enhancer: ArgTypesEnhancer<TRenderer>) => void;
+    _addedExports: Record<string, Store_ModuleExports>;
+    _loadAddedExports(): void;
+    storiesOf: (kind: string, m?: NodeModule) => Addon_StoryApi<TRenderer['storyResult']>;
+    raw: () => _storybook_types.Store_BoundStory<TRenderer>[] | undefined;
+    get _storyStore(): StoryStore<TRenderer> | undefined;
+}
+
+export { ClientApi as C, addArgTypes as a, addArgTypesEnhancer as b, addArgs as c, addArgsEnhancer as d, addDecorator as e, addLoader as f, addParameters as g, addStepRunner as h, setGlobalRender as s };

package/dist/DocsContext-f03e0d93.d.ts

@@ -0,0 +1,322 @@
+import * as _storybook_types from '@storybook/types';
+import { Renderer, StoryId, StoryRenderOptions, ViewMode, Store_Story, RenderToCanvas, Store_RenderContext, Addon_IndexEntry, DocsContextProps, Store_StoryIndex, Store_ModuleImportFn, ProjectAnnotations, Store_PromiseLike, Globals, Args, Store_SelectionSpecifier, Store_Selection, Store_StorySpecifier, Store_CSFFile, Store_ModuleExports, Store_ModuleExport, StoryName, StoryContextForLoaders } from '@storybook/types';
+import { Channel } from '@storybook/channels';
+import { S as StoryStore } from './StoryStore-8f9ab1c2.js';
+
+type RenderType = 'story' | 'docs';
+/**
+ * A "Render" represents the rendering of a single entry to a single location
+ *
+ * The implemenations of render are used for two key purposes:
+ *  - Tracking the state of the rendering as it moves between preparing, rendering and tearing down.
+ *  - Tracking what is rendered to know if a change requires re-rendering or teardown + recreation.
+ */
+interface Render<TRenderer extends Renderer> {
+    type: RenderType;
+    id: StoryId;
+    isPreparing: () => boolean;
+    isEqual: (other: Render<TRenderer>) => boolean;
+    disableKeyListeners: boolean;
+    teardown?: (options: {
+        viewModeChanged: boolean;
+    }) => Promise<void>;
+    torndown: boolean;
+    renderToElement: (canvasElement: TRenderer['canvasElement'], renderStoryToElement?: any, options?: StoryRenderOptions) => Promise<void>;
+}
+
+type RenderPhase = 'preparing' | 'loading' | 'rendering' | 'playing' | 'played' | 'completed' | 'aborted' | 'errored';
+type RenderContextCallbacks<TRenderer extends Renderer> = Pick<Store_RenderContext<TRenderer>, 'showMain' | 'showError' | 'showException'>;
+declare class StoryRender<TRenderer extends Renderer> implements Render<TRenderer> {
+    channel: Channel;
+    store: StoryStore<TRenderer>;
+    private renderToScreen;
+    private callbacks;
+    id: StoryId;
+    viewMode: ViewMode;
+    renderOptions: StoryRenderOptions;
+    type: RenderType;
+    story?: Store_Story<TRenderer>;
+    phase?: RenderPhase;
+    private abortController?;
+    private canvasElement?;
+    private notYetRendered;
+    disableKeyListeners: boolean;
+    private teardownRender;
+    torndown: boolean;
+    constructor(channel: Channel, store: StoryStore<TRenderer>, renderToScreen: RenderToCanvas<TRenderer>, callbacks: RenderContextCallbacks<TRenderer>, id: StoryId, viewMode: ViewMode, renderOptions?: StoryRenderOptions, story?: Store_Story<TRenderer>);
+    private runPhase;
+    prepare(): Promise<void>;
+    isEqual(other: Render<TRenderer>): boolean;
+    isPreparing(): boolean;
+    isPending(): boolean;
+    renderToElement(canvasElement: TRenderer['canvasElement']): Promise<void>;
+    private storyContext;
+    render({ initial, forceRemount, }?: {
+        initial?: boolean;
+        forceRemount?: boolean;
+    }): Promise<void>;
+    rerender(): Promise<void>;
+    remount(): Promise<void>;
+    cancelRender(): void;
+    teardown(): Promise<void>;
+}
+
+/**
+ * A TemplateDocsRender is a render of a docs entry that is rendered with (an) attached CSF file(s).
+ *
+ * The expectation is the primary CSF file which is the `importPath` for the entry will
+ * define a story which may contain the actual rendered JSX code for the template in the
+ * `docs.page` parameter.
+ *
+ * Use cases:
+ *  - Docs Page, where there is no parameter, and we fall back to the globally defined template.
+ *  - *.stories.mdx files, where the MDX compiler produces a CSF file with a `.parameter.docs.page`
+ *      parameter containing the compiled content of the MDX file.
+ */
+declare class TemplateDocsRender<TRenderer extends Renderer> implements Render<TRenderer> {
+    protected channel: Channel;
+    protected store: StoryStore<TRenderer>;
+    entry: Addon_IndexEntry;
+    readonly type: RenderType;
+    readonly id: StoryId;
+    story?: Store_Story<TRenderer>;
+    rerender?: () => Promise<void>;
+    teardownRender?: (options: {
+        viewModeChanged?: boolean;
+    }) => Promise<void>;
+    torndown: boolean;
+    readonly disableKeyListeners = false;
+    preparing: boolean;
+    private csfFiles?;
+    constructor(channel: Channel, store: StoryStore<TRenderer>, entry: Addon_IndexEntry);
+    isPreparing(): boolean;
+    prepare(): Promise<void>;
+    isEqual(other: Render<TRenderer>): boolean;
+    renderToElement(canvasElement: TRenderer['canvasElement'], renderStoryToElement: DocsContextProps['renderStoryToElement']): Promise<void>;
+    teardown({ viewModeChanged }?: {
+        viewModeChanged?: boolean;
+    }): Promise<void>;
+}
+
+/**
+ * A StandaloneDocsRender is a render of a docs entry that doesn't directly come from a CSF file.
+ *
+ * A standalone render can reference zero or more CSF files that contain stories.
+ *
+ * Use cases:
+ *  - *.mdx file that may or may not reference a specific CSF file with `<Meta of={} />`
+ */
+declare class StandaloneDocsRender<TRenderer extends Renderer> implements Render<TRenderer> {
+    protected channel: Channel;
+    protected store: StoryStore<TRenderer>;
+    entry: Addon_IndexEntry;
+    readonly type: RenderType;
+    readonly id: StoryId;
+    private exports?;
+    rerender?: () => Promise<void>;
+    teardownRender?: (options: {
+        viewModeChanged?: boolean;
+    }) => Promise<void>;
+    torndown: boolean;
+    readonly disableKeyListeners = false;
+    preparing: boolean;
+    private csfFiles?;
+    constructor(channel: Channel, store: StoryStore<TRenderer>, entry: Addon_IndexEntry);
+    isPreparing(): boolean;
+    prepare(): Promise<void>;
+    isEqual(other: Render<TRenderer>): boolean;
+    renderToElement(canvasElement: TRenderer['canvasElement'], renderStoryToElement: DocsContextProps['renderStoryToElement']): Promise<void>;
+    teardown({ viewModeChanged }?: {
+        viewModeChanged?: boolean;
+    }): Promise<void>;
+}
+
+type MaybePromise<T> = Promise<T> | T;
+declare class Preview<TFramework extends Renderer> {
+    protected channel: Channel;
+    serverChannel?: Channel;
+    storyStore: StoryStore<TFramework>;
+    getStoryIndex?: () => Store_StoryIndex;
+    importFn?: Store_ModuleImportFn;
+    renderToCanvas?: RenderToCanvas<TFramework>;
+    storyRenders: StoryRender<TFramework>[];
+    previewEntryError?: Error;
+    constructor(channel?: Channel);
+    initialize({ getStoryIndex, importFn, getProjectAnnotations, }: {
+        getStoryIndex?: () => Store_StoryIndex;
+        importFn: Store_ModuleImportFn;
+        getProjectAnnotations: () => MaybePromise<ProjectAnnotations<TFramework>>;
+    }): Promise<void>;
+    setupListeners(): void;
+    getProjectAnnotationsOrRenderError(getProjectAnnotations: () => MaybePromise<ProjectAnnotations<TFramework>>): Store_PromiseLike<ProjectAnnotations<TFramework>>;
+    initializeWithProjectAnnotations(projectAnnotations: ProjectAnnotations<TFramework>): Promise<void>;
+    setInitialGlobals(): Promise<void>;
+    emitGlobals(): void;
+    getStoryIndexFromServer(): Promise<Store_StoryIndex>;
+    initializeWithStoryIndex(storyIndex: Store_StoryIndex): PromiseLike<void>;
+    onGetProjectAnnotationsChanged({ getProjectAnnotations, }: {
+        getProjectAnnotations: () => MaybePromise<ProjectAnnotations<TFramework>>;
+    }): Promise<void>;
+    onStoryIndexChanged(): Promise<void>;
+    onStoriesChanged({ importFn, storyIndex, }: {
+        importFn?: Store_ModuleImportFn;
+        storyIndex?: Store_StoryIndex;
+    }): Promise<void>;
+    onUpdateGlobals({ globals }: {
+        globals: Globals;
+    }): Promise<void>;
+    onUpdateArgs({ storyId, updatedArgs }: {
+        storyId: StoryId;
+        updatedArgs: Args;
+    }): Promise<void>;
+    onResetArgs({ storyId, argNames }: {
+        storyId: string;
+        argNames?: string[];
+    }): Promise<void>;
+    onForceReRender(): Promise<void>;
+    onForceRemount({ storyId }: {
+        storyId: StoryId;
+    }): Promise<void>;
+    renderStoryToElement(story: Store_Story<TFramework>, element: TFramework['canvasElement'], options: StoryRenderOptions): () => Promise<void>;
+    teardownRender(render: StoryRender<TFramework> | TemplateDocsRender<TFramework> | StandaloneDocsRender<TFramework>, { viewModeChanged }?: {
+        viewModeChanged?: boolean;
+    }): Promise<void>;
+    extract(options?: {
+        includeDocsOnly: boolean;
+    }): Promise<Record<string, _storybook_types.StoryContextForEnhancers<TFramework, Args>>>;
+    inlineStoryCallbacks(storyId: StoryId): {
+        showMain: () => void;
+        showError: (err: {
+            title: string;
+            description: string;
+        }) => void;
+        showException: (err: Error) => void;
+    };
+    renderPreviewEntryError(reason: string, err: Error): void;
+}
+
+interface SelectionStore {
+    selectionSpecifier: Store_SelectionSpecifier | null;
+    selection?: Store_Selection;
+    setSelection(selection: Store_Selection): void;
+    setQueryParams(queryParams: qs.ParsedQs): void;
+}
+
+interface View<TStorybookRoot> {
+    prepareForStory(story: Store_Story<any>): TStorybookRoot;
+    prepareForDocs(): TStorybookRoot;
+    showErrorDisplay(err: {
+        message?: string;
+        stack?: string;
+    }): void;
+    showNoPreview(): void;
+    showPreparingStory(options: {
+        immediate: boolean;
+    }): void;
+    showPreparingDocs(): void;
+    showMain(): void;
+    showDocs(): void;
+    showStory(): void;
+    showStoryDuringRender(): void;
+}
+
+type PossibleRender<TFramework extends Renderer> = StoryRender<TFramework> | TemplateDocsRender<TFramework> | StandaloneDocsRender<TFramework>;
+declare class PreviewWithSelection<TFramework extends Renderer> extends Preview<TFramework> {
+    selectionStore: SelectionStore;
+    view: View<TFramework['canvasElement']>;
+    currentSelection?: Store_Selection;
+    currentRender?: PossibleRender<TFramework>;
+    constructor(selectionStore: SelectionStore, view: View<TFramework['canvasElement']>);
+    setupListeners(): void;
+    initializeWithProjectAnnotations(projectAnnotations: ProjectAnnotations<TFramework>): Promise<void>;
+    setInitialGlobals(): Promise<void>;
+    initializeWithStoryIndex(storyIndex: Store_StoryIndex): PromiseLike<void>;
+    selectSpecifiedStory(): Promise<void>;
+    onGetProjectAnnotationsChanged({ getProjectAnnotations, }: {
+        getProjectAnnotations: () => MaybePromise<ProjectAnnotations<TFramework>>;
+    }): Promise<void>;
+    onStoriesChanged({ importFn, storyIndex, }: {
+        importFn?: Store_ModuleImportFn;
+        storyIndex?: Store_StoryIndex;
+    }): Promise<void>;
+    onKeydown(event: KeyboardEvent): void;
+    onSetCurrentStory(selection: {
+        storyId: StoryId;
+        viewMode?: ViewMode;
+    }): Promise<void>;
+    onUpdateQueryParams(queryParams: any): void;
+    onUpdateGlobals({ globals }: {
+        globals: Globals;
+    }): Promise<void>;
+    onUpdateArgs({ storyId, updatedArgs }: {
+        storyId: StoryId;
+        updatedArgs: Args;
+    }): Promise<void>;
+    onPreloadStories({ ids }: {
+        ids: string[];
+    }): Promise<void>;
+    renderSelection({ persistedArgs }?: {
+        persistedArgs?: Args;
+    }): Promise<void>;
+    teardownRender(render: PossibleRender<TFramework>, { viewModeChanged }?: {
+        viewModeChanged?: boolean;
+    }): Promise<void>;
+    extract(options?: {
+        includeDocsOnly: boolean;
+    }): Promise<Record<string, _storybook_types.StoryContextForEnhancers<TFramework, Args>>>;
+    mainStoryCallbacks(storyId: StoryId): {
+        showMain: () => void;
+        showError: (err: {
+            title: string;
+            description: string;
+        }) => void;
+        showException: (err: Error) => void;
+    };
+    inlineStoryCallbacks(storyId: StoryId): {
+        showMain: () => void;
+        showError: (err: {
+            title: string;
+            description: string;
+        }) => void;
+        showException: (err: Error) => void;
+    };
+    renderPreviewEntryError(reason: string, err: Error): void;
+    renderMissingStory(): void;
+    renderStoryLoadingException(storySpecifier: Store_StorySpecifier, err: Error): void;
+    renderException(storyId: StoryId, error: Error): void;
+    renderError(storyId: StoryId, { title, description }: {
+        title: string;
+        description: string;
+    }): void;
+}
+
+declare class PreviewWeb<TFramework extends Renderer> extends PreviewWithSelection<TFramework> {
+    constructor();
+}
+
+declare function simulateDOMContentLoaded(): void;
+declare function simulatePageLoad($container: any): void;
+
+declare class DocsContext<TRenderer extends Renderer> implements DocsContextProps<TRenderer> {
+    channel: Channel;
+    protected store: StoryStore<TRenderer>;
+    renderStoryToElement: DocsContextProps['renderStoryToElement'];
+    private componentStoriesValue;
+    private storyIdToCSFFile;
+    private exportToStoryId;
+    private nameToStoryId;
+    private primaryStory?;
+    constructor(channel: Channel, store: StoryStore<TRenderer>, renderStoryToElement: DocsContextProps['renderStoryToElement'], 
+    /** The CSF files known (via the index) to be refererenced by this docs file */
+    csfFiles: Store_CSFFile<TRenderer>[], componentStoriesFromAllCsfFiles?: boolean);
+    referenceCSFFile(csfFile: Store_CSFFile<TRenderer>, addToComponentStories: boolean): void;
+    setMeta(metaExports: Store_ModuleExports): void;
+    storyIdByModuleExport(storyExport: Store_ModuleExport, metaExports?: Store_ModuleExports): string;
+    storyIdByName: (storyName: StoryName) => string;
+    componentStories: () => Store_Story<TRenderer>[];
+    storyById: (storyId?: StoryId) => Store_Story<TRenderer>;
+    getStoryContext: (story: Store_Story<TRenderer>) => StoryContextForLoaders<TRenderer, _storybook_types.Args>;
+    loadStory: (id: StoryId) => Promise<Store_Story<TRenderer>>;
+}
+
+export { DocsContext as D, Preview as P, simulateDOMContentLoaded as a, PreviewWeb as b, PreviewWithSelection as c, simulatePageLoad as s };

package/dist/StoryStore-8f9ab1c2.d.ts

@@ -0,0 +1,103 @@
+import * as _storybook_types from '@storybook/types';
+import { Store_StoryIndex, Store_StorySpecifier, Addon_IndexEntry, StoryId, Path, Args, Store_Story, Globals, GlobalTypes, Renderer, Store_ModuleExports, ComponentTitle, Store_CSFFile, Store_NormalizedStoryAnnotations, Store_NormalizedComponentAnnotations, Store_NormalizedProjectAnnotations, Store_ModuleImportFn, ProjectAnnotations, Store_PromiseLike, StoryContextForLoaders, Store_ExtractOptions, StoryContextForEnhancers, Parameters, Store_StoryIndexV3, API_PreparedStoryIndex, Store_BoundStory } from '@storybook/types';
+import { SynchronousPromise } from 'synchronous-promise';
+import { H as HooksContext } from './hooks-0d0b05c1.js';
+
+declare class StoryIndexStore {
+    entries: Store_StoryIndex['entries'];
+    constructor({ entries }?: Store_StoryIndex);
+    entryFromSpecifier(specifier: Store_StorySpecifier): Addon_IndexEntry | undefined;
+    storyIdToEntry(storyId: StoryId): Addon_IndexEntry;
+    importPathToEntry(importPath: Path): Addon_IndexEntry;
+}
+
+declare class ArgsStore {
+    initialArgsByStoryId: Record<StoryId, Args>;
+    argsByStoryId: Record<StoryId, Args>;
+    get(storyId: StoryId): Args;
+    setInitial(story: Store_Story<any>): void;
+    updateFromDelta(story: Store_Story<any>, delta: Args): void;
+    updateFromPersisted(story: Store_Story<any>, persisted: Args): void;
+    update(storyId: StoryId, argsUpdate: Partial<Args>): void;
+}
+
+declare class GlobalsStore {
+    allowedGlobalNames: Set<string>;
+    initialGlobals: Globals;
+    globals: Globals;
+    constructor({ globals, globalTypes, }: {
+        globals?: Globals;
+        globalTypes?: GlobalTypes;
+    });
+    set({ globals, globalTypes }: {
+        globals?: Globals;
+        globalTypes?: GlobalTypes;
+    }): void;
+    filterAllowedGlobals(globals: Globals): Globals;
+    updateFromPersisted(persisted: Globals): void;
+    get(): Globals;
+    update(newGlobals: Globals): void;
+}
+
+declare function processCSFFile<TRenderer extends Renderer>(moduleExports: Store_ModuleExports, importPath: Path, title: ComponentTitle): Store_CSFFile<TRenderer>;
+
+declare function prepareStory<TRenderer extends Renderer>(storyAnnotations: Store_NormalizedStoryAnnotations<TRenderer>, componentAnnotations: Store_NormalizedComponentAnnotations<TRenderer>, projectAnnotations: Store_NormalizedProjectAnnotations<TRenderer>): Store_Story<TRenderer>;
+
+declare class StoryStore<TRenderer extends Renderer> {
+    storyIndex?: StoryIndexStore;
+    importFn?: Store_ModuleImportFn;
+    projectAnnotations?: Store_NormalizedProjectAnnotations<TRenderer>;
+    globals?: GlobalsStore;
+    args: ArgsStore;
+    hooks: Record<StoryId, HooksContext<TRenderer>>;
+    cachedCSFFiles?: Record<Path, Store_CSFFile<TRenderer>>;
+    processCSFFileWithCache: typeof processCSFFile;
+    prepareStoryWithCache: typeof prepareStory;
+    initializationPromise: SynchronousPromise<void>;
+    resolveInitializationPromise: () => void;
+    constructor();
+    setProjectAnnotations(projectAnnotations: ProjectAnnotations<TRenderer>): void;
+    initialize({ storyIndex, importFn, cache, }: {
+        storyIndex?: Store_StoryIndex;
+        importFn: Store_ModuleImportFn;
+        cache?: boolean;
+    }): Store_PromiseLike<void>;
+    onStoriesChanged({ importFn, storyIndex, }: {
+        importFn?: Store_ModuleImportFn;
+        storyIndex?: Store_StoryIndex;
+    }): Promise<void>;
+    storyIdToEntry(storyId: StoryId): Promise<Addon_IndexEntry>;
+    loadCSFFileByStoryId(storyId: StoryId): Store_PromiseLike<Store_CSFFile<TRenderer>>;
+    loadAllCSFFiles(): Store_PromiseLike<StoryStore<TRenderer>['cachedCSFFiles']>;
+    cacheAllCSFFiles(): Store_PromiseLike<void>;
+    loadStory({ storyId }: {
+        storyId: StoryId;
+    }): Promise<Store_Story<TRenderer>>;
+    storyFromCSFFile({ storyId, csfFile, }: {
+        storyId: StoryId;
+        csfFile: Store_CSFFile<TRenderer>;
+    }): Store_Story<TRenderer>;
+    componentStoriesFromCSFFile({ csfFile, }: {
+        csfFile: Store_CSFFile<TRenderer>;
+    }): Store_Story<TRenderer>[];
+    loadEntry(id: StoryId): Promise<{
+        entryExports: Store_ModuleExports;
+        csfFiles: Store_CSFFile<TRenderer>[];
+    }>;
+    getStoryContext(story: Store_Story<TRenderer>): Omit<StoryContextForLoaders<TRenderer>, 'viewMode'>;
+    cleanupStory(story: Store_Story<TRenderer>): void;
+    extract(options?: Store_ExtractOptions): Record<StoryId, StoryContextForEnhancers<TRenderer>>;
+    getSetStoriesPayload(): {
+        v: number;
+        globals: _storybook_types.Globals;
+        globalParameters: {};
+        kindParameters: Parameters;
+        stories: Record<string, StoryContextForEnhancers<TRenderer, _storybook_types.Args>>;
+    };
+    getStoriesJsonData: () => Store_StoryIndexV3;
+    getSetIndexPayload(): API_PreparedStoryIndex;
+    raw(): Store_BoundStory<TRenderer>[];
+    fromId(storyId: StoryId): Store_BoundStory<TRenderer> | null;
+}
+
+export { StoryStore as S, processCSFFile as a, prepareStory as p };

package/dist/addons.d.ts

@@ -0,0 +1,4 @@
+export { A as AddonStore, c as MakeDecoratorOptions, M as MakeDecoratorResult, a as addons, m as makeDecorator, b as mockChannel } from './storybook-channel-mock-e42c60b1.js';
+export { E as EventMap, H as HooksContext, L as Listener, k as applyHooks, u as useArgs, a as useCallback, b as useChannel, c as useEffect, d as useGlobals, e as useMemo, f as useParameter, g as useReducer, h as useRef, i as useState, j as useStoryContext } from './hooks-0d0b05c1.js';
+import '@storybook/channels';
+import '@storybook/types';

package/dist/addons.js

@@ -0,0 +1,4 @@
+"use strict";var L=Object.create;var p=Object.defineProperty;var P=Object.getOwnPropertyDescriptor;var _=Object.getOwnPropertyNames;var M=Object.getPrototypeOf,I=Object.prototype.hasOwnProperty;var U=(r,e)=>{for(var n in e)p(r,n,{get:e[n],enumerable:!0})},C=(r,e,n,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of _(e))!I.call(r,t)&&t!==n&&p(r,t,{get:()=>e[t],enumerable:!(o=P(e,t))||o.enumerable});return r};var A=(r,e,n)=>(n=r!=null?L(M(r)):{},C(e||!r||!r.__esModule?p(n,"default",{value:r,enumerable:!0}):n,r)),F=r=>C(p({},"__esModule",{value:!0}),r);var re={};U(re,{AddonStore:()=>S,HooksContext:()=>T,addons:()=>d,applyHooks:()=>Y,makeDecorator:()=>ee,mockChannel:()=>g,useArgs:()=>Q,useCallback:()=>f,useChannel:()=>V,useEffect:()=>N,useGlobals:()=>Z,useMemo:()=>W,useParameter:()=>J,useReducer:()=>q,useRef:()=>z,useState:()=>X,useStoryContext:()=>k});module.exports=F(re);var y=A(require("global"));var O=require("@storybook/channels");function g(){let r={setHandler:()=>{},send:()=>{}};return new O.Channel({transport:r})}var S=class{constructor(){this.getChannel=()=>{if(!this.channel){let e=g();return this.setChannel(e),e}return this.channel};this.getServerChannel=()=>{if(!this.serverChannel)throw new Error("Accessing non-existent serverChannel");return this.serverChannel};this.ready=()=>this.promise;this.hasChannel=()=>!!this.channel;this.hasServerChannel=()=>!!this.serverChannel;this.setChannel=e=>{this.channel=e,this.resolve()};this.setServerChannel=e=>{this.serverChannel=e};this.promise=new Promise(e=>{this.resolve=()=>e(this.getChannel())})}},v="__STORYBOOK_ADDONS_PREVIEW";function $(){return y.default[v]||(y.default[v]=new S),y.default[v]}var d=$();var l=A(require("global")),h=require("@storybook/client-logger"),i=require("@storybook/core-events");var T=class{constructor(){this.hookListsMap=void 0;this.mountedDecorators=void 0;this.prevMountedDecorators=void 0;this.currentHooks=void 0;this.nextHookIndex=void 0;this.currentPhase=void 0;this.currentEffects=void 0;this.prevEffects=void 0;this.currentDecoratorName=void 0;this.hasUpdates=void 0;this.currentContext=void 0;this.renderListener=e=>{var n;e===((n=this.currentContext)==null?void 0:n.id)&&(this.triggerEffects(),this.currentContext=null,this.removeRenderListeners())};this.init()}init(){this.hookListsMap=new WeakMap,this.mountedDecorators=new Set,this.prevMountedDecorators=this.mountedDecorators,this.currentHooks=[],this.nextHookIndex=0,this.currentPhase="NONE",this.currentEffects=[],this.prevEffects=[],this.currentDecoratorName=null,this.hasUpdates=!1,this.currentContext=null}clean(){this.prevEffects.forEach(e=>{e.destroy&&e.destroy()}),this.init(),this.removeRenderListeners()}getNextHook(){let e=this.currentHooks[this.nextHookIndex];return this.nextHookIndex+=1,e}triggerEffects(){this.prevEffects.forEach(e=>{!this.currentEffects.includes(e)&&e.destroy&&e.destroy()}),this.currentEffects.forEach(e=>{this.prevEffects.includes(e)||(e.destroy=e.create())}),this.prevEffects=this.currentEffects,this.currentEffects=[]}addRenderListeners(){this.removeRenderListeners(),d.getChannel().on(i.STORY_RENDERED,this.renderListener)}removeRenderListeners(){d.getChannel().removeListener(i.STORY_RENDERED,this.renderListener)}};function b(r){return(...e)=>{let{hooks:n}=typeof e[0]=="function"?e[1]:e[0],o=n.currentPhase,t=n.currentHooks,s=n.nextHookIndex,a=n.currentDecoratorName;n.currentDecoratorName=r.name,n.prevMountedDecorators.has(r)?(n.currentPhase="UPDATE",n.currentHooks=n.hookListsMap.get(r)||[]):(n.currentPhase="MOUNT",n.currentHooks=[],n.hookListsMap.set(r,n.currentHooks),n.prevMountedDecorators.add(r)),n.nextHookIndex=0;let c=l.default.STORYBOOK_HOOKS_CONTEXT;l.default.STORYBOOK_HOOKS_CONTEXT=n;let u=r(...e);if(l.default.STORYBOOK_HOOKS_CONTEXT=c,n.currentPhase==="UPDATE"&&n.getNextHook()!=null)throw new Error("Rendered fewer hooks than expected. This may be caused by an accidental early return statement.");return n.currentPhase=o,n.currentHooks=t,n.nextHookIndex=s,n.currentDecoratorName=a,u}}var R=0,K=25,Y=r=>(e,n)=>{let o=r(b(e),n.map(t=>b(t)));return t=>{let{hooks:s}=t;s.prevMountedDecorators=s.mountedDecorators,s.mountedDecorators=new Set([e,...n]),s.currentContext=t,s.hasUpdates=!1;let a=o(t);for(R=1;s.hasUpdates;)if(s.hasUpdates=!1,s.currentEffects=[],a=o(t),R+=1,R>K)throw new Error("Too many re-renders. Storybook limits the number of renders to prevent an infinite loop.");return s.addRenderListeners(),a}},B=(r,e)=>r.length===e.length&&r.every((n,o)=>n===e[o]),E=()=>new Error("Storybook preview hooks can only be called inside decorators and story functions.");function D(){return l.default.STORYBOOK_HOOKS_CONTEXT||null}function x(){let r=D();if(r==null)throw E();return r}function G(r,e,n){let o=x();if(o.currentPhase==="MOUNT"){n!=null&&!Array.isArray(n)&&h.logger.warn(`${r} received a final argument that is not an array (instead, received ${n}). When specified, the final argument must be an array.`);let t={name:r,deps:n};return o.currentHooks.push(t),e(t),t}if(o.currentPhase==="UPDATE"){let t=o.getNextHook();if(t==null)throw new Error("Rendered more hooks than during the previous render.");return t.name!==r&&h.logger.warn(`Storybook has detected a change in the order of Hooks${o.currentDecoratorName?` called by ${o.currentDecoratorName}`:""}. This will lead to bugs and errors if not fixed.`),n!=null&&t.deps==null&&h.logger.warn(`${r} received a final argument during this render, but not during the previous render. Even though the final argument is optional, its type cannot change between renders.`),n!=null&&t.deps!=null&&n.length!==t.deps.length&&h.logger.warn(`The final argument passed to ${r} changed size between renders. The order and size of this array must remain constant.
+Previous: ${t.deps}
+Incoming: ${n}`),(n==null||t.deps==null||!B(n,t.deps))&&(e(t),t.deps=n),t}throw E()}function m(r,e,n){let{memoizedState:o}=G(r,t=>{t.memoizedState=e()},n);return o}function W(r,e){return m("useMemo",r,e)}function f(r,e){return m("useCallback",()=>r,e)}function H(r,e){return m(r,()=>({current:e}),[])}function z(r){return H("useRef",r)}function j(){let r=D();if(r!=null&&r.currentPhase!=="NONE")r.hasUpdates=!0;else try{d.getChannel().emit(i.FORCE_RE_RENDER)}catch{h.logger.warn("State updates of Storybook preview hooks work only in browser")}}function w(r,e){let n=H(r,typeof e=="function"?e():e),o=t=>{n.current=typeof t=="function"?t(n.current):t,j()};return[n.current,o]}function X(r){return w("useState",r)}function q(r,e,n){let o=n!=null?()=>n(e):e,[t,s]=w("useReducer",o);return[t,c=>s(u=>r(u,c))]}function N(r,e){let n=x(),o=m("useEffect",()=>({create:r}),e);n.currentEffects.includes(o)||n.currentEffects.push(o)}function V(r,e=[]){let n=d.getChannel();return N(()=>(Object.entries(r).forEach(([o,t])=>n.on(o,t)),()=>{Object.entries(r).forEach(([o,t])=>n.removeListener(o,t))}),[...Object.keys(r),...e]),f(n.emit.bind(n),[n])}function k(){let{currentContext:r}=x();if(r==null)throw E();return r}function J(r,e){let{parameters:n}=k();if(r)return n[r]??e}function Q(){let r=d.getChannel(),{id:e,args:n}=k(),o=f(s=>r.emit(i.UPDATE_STORY_ARGS,{storyId:e,updatedArgs:s}),[r,e]),t=f(s=>r.emit(i.RESET_STORY_ARGS,{storyId:e,argNames:s}),[r,e]);return[n,o,t]}function Z(){let r=d.getChannel(),{globals:e}=k(),n=f(o=>r.emit(i.UPDATE_GLOBALS,{globals:o}),[r]);return[e,n]}var ee=({name:r,parameterName:e,wrapper:n,skipIfNoParametersOrOptions:o=!1})=>{let t=s=>(a,c)=>{let u=c.parameters&&c.parameters[e];return u&&u.disable||o&&!s&&!u?a(c):n(a,c,{options:s,parameters:u})};return(...s)=>typeof s[0]=="function"?t()(...s):(...a)=>{if(a.length>1)return s.length>1?t(s)(...a):t(...s)(...a);throw new Error(`Passing stories directly into ${r}() is not allowed,
+        instead use addDecorator(${r}) and pass options with the '${e}' parameter`)}};0&&(module.exports={AddonStore,HooksContext,addons,applyHooks,makeDecorator,mockChannel,useArgs,useCallback,useChannel,useEffect,useGlobals,useMemo,useParameter,useReducer,useRef,useState,useStoryContext});

package/dist/addons.mjs

@@ -0,0 +1 @@
+import{makeDecorator}from"./chunk-GRRYLBAT.mjs";import{AddonStore,HooksContext,addons,applyHooks,mockChannel,useArgs,useCallback,useChannel,useEffect,useGlobals,useMemo,useParameter,useReducer,useRef,useState,useStoryContext}from"./chunk-QSH26RWA.mjs";export{AddonStore,HooksContext,addons,applyHooks,makeDecorator,mockChannel,useArgs,useCallback,useChannel,useEffect,useGlobals,useMemo,useParameter,useReducer,useRef,useState,useStoryContext};