@storybook/addons

  • Version 6.5.12
  • Published
  • 105 kB
  • 11 dependencies
  • MIT license

Install

npm i @storybook/addons
yarn add @storybook/addons
pnpm add @storybook/addons

Overview

Storybook addons store

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable addons

const addons: AddonStore;

    Functions

    function applyHooks

    applyHooks: <TFramework extends AnyFramework>(
    applyDecorators: DecoratorApplicator<TFramework, Args>
    ) => DecoratorApplicator<TFramework, Args>;

      function isSupportedType

      isSupportedType: (type: Types) => boolean;

        function makeDecorator

        makeDecorator: ({
        name,
        parameterName,
        wrapper,
        skipIfNoParametersOrOptions,
        }: MakeDecoratorOptions) => MakeDecoratorResult;

          function mockChannel

          mockChannel: () => Channel;

            function useArgs

            useArgs: () => [Args, (newArgs: Args) => void, (argNames?: [string]) => void];

              function useCallback

              useCallback: <T>(callback: T, deps?: any[]) => T;

                function useChannel

                useChannel: (eventMap: EventMap, deps?: any[]) => any;

                  function useEffect

                  useEffect: (create: () => (() => void) | void, deps?: any[]) => void;

                    function useGlobals

                    useGlobals: () => [Args, (newGlobals: Args) => void];

                      function useMemo

                      useMemo: <T>(nextCreate: () => T, deps?: any[]) => T;

                        function useParameter

                        useParameter: <S>(parameterKey: string, defaultValue?: S) => S | undefined;

                          function useReducer

                          useReducer: {
                          <S, A>(reducer: (state: S, action: A) => S, initialState: S): [
                          S,
                          (action: A) => void
                          ];
                          <S, I, A>(
                          reducer: (state: S, action: A) => S,
                          initialArg: I,
                          init: (initialArg: I) => S
                          ): [S, (action: A) => void];
                          };

                            function useRef

                            useRef: <T>(initialValue: T) => { current: T };

                              function useState

                              useState: <S>(
                              initialState: (() => S) | S
                              ) => [S, (update: S | ((prevState: S) => S)) => void];

                                function useStoryContext

                                useStoryContext: <TFramework extends AnyFramework>() => StoryContext<TFramework>;

                                  Classes

                                  class AddonStore

                                  class AddonStore {}

                                    constructor

                                    constructor();

                                      property add

                                      add: (name: string, addon: Addon) => void;

                                        property addPanel

                                        addPanel: (name: string, options: Addon) => void;

                                          property getChannel

                                          getChannel: () => Channel;

                                            property getConfig

                                            getConfig: () => Config;

                                              property getElements

                                              getElements: (type: Types) => Collection;

                                                property getServerChannel

                                                getServerChannel: () => Channel;

                                                  property hasChannel

                                                  hasChannel: () => boolean;

                                                    property hasServerChannel

                                                    hasServerChannel: () => boolean;

                                                      property loadAddons

                                                      loadAddons: (api: any) => void;

                                                        property ready

                                                        ready: () => Promise<Channel>;

                                                          property register

                                                          register: (name: string, registerCallback: (api: API) => void) => void;

                                                            property setChannel

                                                            setChannel: (channel: Channel) => void;

                                                              property setConfig

                                                              setConfig: (value: Config) => void;

                                                                property setServerChannel

                                                                setServerChannel: (channel: Channel) => void;

                                                                  class HooksContext

                                                                  class HooksContext<TFramework extends AnyFramework> {}

                                                                    constructor

                                                                    constructor();

                                                                      property currentContext

                                                                      currentContext: any;

                                                                        property currentDecoratorName

                                                                        currentDecoratorName: string;

                                                                          property currentEffects

                                                                          currentEffects: Effect[];

                                                                            property currentHooks

                                                                            currentHooks: Hook[];

                                                                              property currentPhase

                                                                              currentPhase: 'MOUNT' | 'UPDATE' | 'NONE';

                                                                                property hasUpdates

                                                                                hasUpdates: boolean;

                                                                                  property hookListsMap

                                                                                  hookListsMap: WeakMap<AbstractFunction, Hook[]>;

                                                                                    property mountedDecorators

                                                                                    mountedDecorators: Set<AbstractFunction>;

                                                                                      property nextHookIndex

                                                                                      nextHookIndex: number;

                                                                                        property prevEffects

                                                                                        prevEffects: Effect[];

                                                                                          property prevMountedDecorators

                                                                                          prevMountedDecorators: Set<AbstractFunction>;

                                                                                            property renderListener

                                                                                            renderListener: (storyId: StoryId) => void;

                                                                                              method addRenderListeners

                                                                                              addRenderListeners: () => void;

                                                                                                method clean

                                                                                                clean: () => void;

                                                                                                  method getNextHook

                                                                                                  getNextHook: () => Hook;

                                                                                                    method init

                                                                                                    init: () => void;

                                                                                                      method removeRenderListeners

                                                                                                      removeRenderListeners: () => void;

                                                                                                        method triggerEffects

                                                                                                        triggerEffects: () => void;

                                                                                                          Interfaces

                                                                                                          interface Addon

                                                                                                          interface Addon {}

                                                                                                            property disabled

                                                                                                            disabled?: boolean;

                                                                                                              property hidden

                                                                                                              hidden?: boolean;

                                                                                                                property id

                                                                                                                id?: string;

                                                                                                                  property match

                                                                                                                  match?: (matchOptions: RouterData) => boolean;

                                                                                                                    property paramKey

                                                                                                                    paramKey?: string;

                                                                                                                      property render

                                                                                                                      render: (renderOptions: RenderOptions) => ReactElement<any>;

                                                                                                                        property route

                                                                                                                        route?: (routeOptions: RouterData) => string;

                                                                                                                          property title

                                                                                                                          title: (() => string) | string;

                                                                                                                            property type

                                                                                                                            type?: Types;

                                                                                                                              interface AddStoryArgs

                                                                                                                              interface AddStoryArgs<StoryFnReturnType = unknown> {}

                                                                                                                                property id

                                                                                                                                id: StoryId;

                                                                                                                                  property kind

                                                                                                                                  kind: StoryKind;

                                                                                                                                    property name

                                                                                                                                    name: StoryName;

                                                                                                                                      property parameters

                                                                                                                                      parameters: Parameters;

                                                                                                                                        property storyFn

                                                                                                                                        storyFn: StoryFn<StoryFnReturnType>;

                                                                                                                                          interface Annotations

                                                                                                                                          interface Annotations<Args, StoryFnReturnType>
                                                                                                                                          extends BaseAnnotations<Args, StoryFnReturnType> {}

                                                                                                                                            property excludeStories

                                                                                                                                            excludeStories?: string[] | RegExp;
                                                                                                                                            • Used to exclude certain named exports. Useful when you want to have non-story exports such as mock data or ignore a few stories.

                                                                                                                                              Example 1

                                                                                                                                              excludeStories: ['simpleData', 'complexData'] excludeStories: /.*Data$/

                                                                                                                                              See Also

                                                                                                                                              • [Non-story exports](https://storybook.js.org/docs/formats/component-story-format/#non-story-exports)

                                                                                                                                            property includeStories

                                                                                                                                            includeStories?: string[] | RegExp;
                                                                                                                                            • Used to only include certain named exports as stories. Useful when you want to have non-story exports such as mock data or ignore a few stories.

                                                                                                                                              Example 1

                                                                                                                                              includeStories: ['SimpleStory', 'ComplexStory'] includeStories: /.*Story$/

                                                                                                                                              See Also

                                                                                                                                              • [Non-story exports](https://storybook.js.org/docs/formats/component-story-format/#non-story-exports)

                                                                                                                                            interface ArgType

                                                                                                                                            interface ArgType<TArg = unknown> extends InputType {}

                                                                                                                                              property defaultValue

                                                                                                                                              defaultValue?: TArg;

                                                                                                                                                interface BaseAnnotations

                                                                                                                                                interface BaseAnnotations<Args, StoryFnReturnType> {}

                                                                                                                                                  property args

                                                                                                                                                  args?: Partial<Args>;
                                                                                                                                                  • Dynamic data that are provided (and possibly updated by) Storybook and its addons.

                                                                                                                                                    See Also

                                                                                                                                                    • [Arg story inputs](https://storybook.js.org/docs/react/api/csf#args-story-inputs)

                                                                                                                                                  property argTypes

                                                                                                                                                  argTypes?: ArgTypes<Args>;
                                                                                                                                                  • ArgTypes encode basic metadata for args, such as name, description, defaultValue for an arg. These get automatically filled in by Storybook Docs.

                                                                                                                                                    See Also

                                                                                                                                                    • [Control annotations](https://github.com/storybookjs/storybook/blob/91e9dee33faa8eff0b342a366845de7100415367/addons/controls/README.md#control-annotations)

                                                                                                                                                  property decorators

                                                                                                                                                  decorators?: BaseDecorators<StoryFnReturnType>;
                                                                                                                                                  • Wrapper components or Storybook decorators that wrap a story.

                                                                                                                                                    Decorators defined in Meta will be applied to every story variation.

                                                                                                                                                    See Also

                                                                                                                                                    • [Decorators](https://storybook.js.org/docs/addons/introduction/#1-decorators)

                                                                                                                                                  property parameters

                                                                                                                                                  parameters?: Parameters;
                                                                                                                                                  • Custom metadata for a story.

                                                                                                                                                    See Also

                                                                                                                                                    • [Parameters](https://storybook.js.org/docs/basics/writing-stories/#parameters)

                                                                                                                                                  property play

                                                                                                                                                  play?: (context: StoryContext) => Promise<void> | void;
                                                                                                                                                  • Function that is executed after the story is rendered.

                                                                                                                                                  property render

                                                                                                                                                  render?: (args: Args, context: StoryContext) => StoryFnReturnType;
                                                                                                                                                  • Define a custom render function for the story(ies). If not passed, a default render function by the framework will be used.

                                                                                                                                                  interface BaseMeta

                                                                                                                                                  interface BaseMeta<ComponentType> {}

                                                                                                                                                    property component

                                                                                                                                                    component?: ComponentType;
                                                                                                                                                    • The primary component for your story.

                                                                                                                                                      Used by addons for automatic prop table generation and display of other component metadata.

                                                                                                                                                    property id

                                                                                                                                                    id?: string;
                                                                                                                                                    • Manually set the id of a story, which in particular is useful if you want to rename stories without breaking permalinks.

                                                                                                                                                      Storybook will prioritize the id over the title for ID generation, if provided, and will prioritize the story.storyName over the export key for display.

                                                                                                                                                      See Also

                                                                                                                                                      • [Sidebar and URLs](https://storybook.js.org/docs/react/configure/sidebar-and-urls#permalinking-to-stories)

                                                                                                                                                    property subcomponents

                                                                                                                                                    subcomponents?: Record<string, ComponentType>;
                                                                                                                                                    • Auxiliary subcomponents that are part of the stories.

                                                                                                                                                      Used by addons for automatic prop table generation and display of other component metadata.

                                                                                                                                                      Example 1

                                                                                                                                                      import { Button, ButtonGroup } from './components';

                                                                                                                                                      export default { ... subcomponents: { Button, ButtonGroup } }

                                                                                                                                                      By defining them each component will have its tab in the args table.

                                                                                                                                                    property title

                                                                                                                                                    title?: string;
                                                                                                                                                    • Title of the story which will be presented in the navigation. **Should be unique.**

                                                                                                                                                      Stories can be organized in a nested structure using "/" as a separator.

                                                                                                                                                      Since CSF 3.0 this property is optional.

                                                                                                                                                      Example 1

                                                                                                                                                      export default { ... title: 'Design System/Atoms/Button' }

                                                                                                                                                      See Also

                                                                                                                                                      • [Story Hierarchy](https://storybook.js.org/docs/basics/writing-stories/#story-hierarchy)

                                                                                                                                                    interface ClientApiAddon

                                                                                                                                                    interface ClientApiAddon<StoryFnReturnType = unknown> extends Addon {}

                                                                                                                                                      property apply

                                                                                                                                                      apply: (a: StoryApi<StoryFnReturnType>, b: any[]) => any;

                                                                                                                                                        interface ClientApiAddons

                                                                                                                                                        interface ClientApiAddons<StoryFnReturnType> {}

                                                                                                                                                          index signature

                                                                                                                                                          [key: string]: ClientApiAddon<StoryFnReturnType>;

                                                                                                                                                            interface ClientStoryApi

                                                                                                                                                            interface ClientStoryApi<StoryFnReturnType = unknown> {}

                                                                                                                                                              method addDecorator

                                                                                                                                                              addDecorator: (
                                                                                                                                                              decorator: DecoratorFunctionForFramework<
                                                                                                                                                              ReturnTypeFramework<StoryFnReturnType>
                                                                                                                                                              >
                                                                                                                                                              ) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                method addParameters

                                                                                                                                                                addParameters: (parameter: Parameters) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                  method storiesOf

                                                                                                                                                                  storiesOf: (kind: StoryKind, module: NodeModule) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                    interface Collection

                                                                                                                                                                    interface Collection {}

                                                                                                                                                                      index signature

                                                                                                                                                                      [key: string]: Addon;

                                                                                                                                                                        interface Config

                                                                                                                                                                        interface Config {}

                                                                                                                                                                          property theme

                                                                                                                                                                          theme?: ThemeVars;

                                                                                                                                                                            property toolbar

                                                                                                                                                                            toolbar?: {
                                                                                                                                                                            [id: string]: ToolbarConfig;
                                                                                                                                                                            };

                                                                                                                                                                              index signature

                                                                                                                                                                              [key: string]: any;

                                                                                                                                                                                interface EventMap

                                                                                                                                                                                interface EventMap {}

                                                                                                                                                                                  index signature

                                                                                                                                                                                  [eventId: string]: Listener;

                                                                                                                                                                                    interface IStorybookSection

                                                                                                                                                                                    interface IStorybookSection {}

                                                                                                                                                                                      property kind

                                                                                                                                                                                      kind: string;

                                                                                                                                                                                        property stories

                                                                                                                                                                                        stories: IStorybookStory[];

                                                                                                                                                                                          interface IStorybookStory

                                                                                                                                                                                          interface IStorybookStory {}

                                                                                                                                                                                            property name

                                                                                                                                                                                            name: string;

                                                                                                                                                                                              property render

                                                                                                                                                                                              render: (context: any) => any;

                                                                                                                                                                                                interface Listener

                                                                                                                                                                                                interface Listener {}

                                                                                                                                                                                                  call signature

                                                                                                                                                                                                  (...args: any[]): void;

                                                                                                                                                                                                    interface OptionsParameter

                                                                                                                                                                                                    interface OptionsParameter extends Object {}

                                                                                                                                                                                                      property storySort

                                                                                                                                                                                                      storySort?: StorySortParameter;

                                                                                                                                                                                                        property theme

                                                                                                                                                                                                        theme?: {
                                                                                                                                                                                                        base: string;
                                                                                                                                                                                                        brandTitle?: string;
                                                                                                                                                                                                        };

                                                                                                                                                                                                          index signature

                                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                                            interface Parameters

                                                                                                                                                                                                            interface Parameters {}

                                                                                                                                                                                                              property docsOnly

                                                                                                                                                                                                              docsOnly?: boolean;

                                                                                                                                                                                                                property fileName

                                                                                                                                                                                                                fileName?: string;

                                                                                                                                                                                                                  property layout

                                                                                                                                                                                                                  layout?: 'centered' | 'fullscreen' | 'padded' | 'none';
                                                                                                                                                                                                                  • The layout property defines basic styles added to the preview body where the story is rendered. If you pass 'none', no styles are applied.

                                                                                                                                                                                                                  property options

                                                                                                                                                                                                                  options?: OptionsParameter;

                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                    [key: string]: any;

                                                                                                                                                                                                                      interface RenderOptions

                                                                                                                                                                                                                      interface RenderOptions {}

                                                                                                                                                                                                                        property active

                                                                                                                                                                                                                        active?: boolean;

                                                                                                                                                                                                                          property key

                                                                                                                                                                                                                          key?: string;

                                                                                                                                                                                                                            interface StoryApi

                                                                                                                                                                                                                            interface StoryApi<StoryFnReturnType = unknown> {}

                                                                                                                                                                                                                              property add

                                                                                                                                                                                                                              add: (
                                                                                                                                                                                                                              storyName: StoryName,
                                                                                                                                                                                                                              storyFn: StoryFn<StoryFnReturnType>,
                                                                                                                                                                                                                              parameters?: Parameters
                                                                                                                                                                                                                              ) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                                                                                property addDecorator

                                                                                                                                                                                                                                addDecorator: (
                                                                                                                                                                                                                                decorator: DecoratorFunction<StoryFnReturnType>
                                                                                                                                                                                                                                ) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                                                                                  property addLoader

                                                                                                                                                                                                                                  addLoader: (decorator: LoaderFunction) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                                                                                    property addParameters

                                                                                                                                                                                                                                    addParameters: (parameters: Parameters) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                      kind: StoryKind;

                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                        [k: string]: string | ClientApiReturnFn<StoryFnReturnType>;

                                                                                                                                                                                                                                          interface StorySortObjectParameter

                                                                                                                                                                                                                                          interface StorySortObjectParameter {}

                                                                                                                                                                                                                                            property includeNames

                                                                                                                                                                                                                                            includeNames?: boolean;

                                                                                                                                                                                                                                              property locales

                                                                                                                                                                                                                                              locales?: string;

                                                                                                                                                                                                                                                property method

                                                                                                                                                                                                                                                method?: StorySortMethod;

                                                                                                                                                                                                                                                  property order

                                                                                                                                                                                                                                                  order?: any[];

                                                                                                                                                                                                                                                    interface WrapperSettings

                                                                                                                                                                                                                                                    interface WrapperSettings {}

                                                                                                                                                                                                                                                      property options

                                                                                                                                                                                                                                                      options: object;

                                                                                                                                                                                                                                                        property parameters

                                                                                                                                                                                                                                                        parameters: {
                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                          Enums

                                                                                                                                                                                                                                                          enum types

                                                                                                                                                                                                                                                          enum types {
                                                                                                                                                                                                                                                          TAB = 'tab',
                                                                                                                                                                                                                                                          PANEL = 'panel',
                                                                                                                                                                                                                                                          TOOL = 'tool',
                                                                                                                                                                                                                                                          TOOLEXTRA = 'toolextra',
                                                                                                                                                                                                                                                          PREVIEW = 'preview',
                                                                                                                                                                                                                                                          NOTES_ELEMENT = 'notes-element',
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            member NOTES_ELEMENT

                                                                                                                                                                                                                                                            NOTES_ELEMENT = 'notes-element'

                                                                                                                                                                                                                                                              member PANEL

                                                                                                                                                                                                                                                              PANEL = 'panel'

                                                                                                                                                                                                                                                                member PREVIEW

                                                                                                                                                                                                                                                                PREVIEW = 'preview'

                                                                                                                                                                                                                                                                  member TAB

                                                                                                                                                                                                                                                                  TAB = 'tab'

                                                                                                                                                                                                                                                                    member TOOL

                                                                                                                                                                                                                                                                    TOOL = 'tool'

                                                                                                                                                                                                                                                                      member TOOLEXTRA

                                                                                                                                                                                                                                                                      TOOLEXTRA = 'toolextra'

                                                                                                                                                                                                                                                                        Type Aliases

                                                                                                                                                                                                                                                                        type ArgsStoryFn

                                                                                                                                                                                                                                                                        type ArgsStoryFn<ReturnType = unknown> = ArgsStoryFnForFramework<
                                                                                                                                                                                                                                                                        ReturnTypeFramework<ReturnType>
                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                          type ArgTypes

                                                                                                                                                                                                                                                                          type ArgTypes<TArgs = Args> = {
                                                                                                                                                                                                                                                                          [key in keyof Partial<TArgs>]: ArgType<TArgs[key]>;
                                                                                                                                                                                                                                                                          } & {
                                                                                                                                                                                                                                                                          [key in string]: ArgType<unknown>;
                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                            type BaseDecorators

                                                                                                                                                                                                                                                                            type BaseDecorators<StoryFnReturnType> = Array<
                                                                                                                                                                                                                                                                            (story: () => StoryFnReturnType, context: StoryContext) => StoryFnReturnType
                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                              type BaseStory

                                                                                                                                                                                                                                                                              type BaseStory<Args, StoryFnReturnType> =
                                                                                                                                                                                                                                                                              | BaseStoryFn<Args, StoryFnReturnType>
                                                                                                                                                                                                                                                                              | BaseStoryObject<Args, StoryFnReturnType>;

                                                                                                                                                                                                                                                                                type BaseStoryFn

                                                                                                                                                                                                                                                                                type BaseStoryFn<Args, StoryFnReturnType> = {
                                                                                                                                                                                                                                                                                (args: Args, context: StoryContext): StoryFnReturnType;
                                                                                                                                                                                                                                                                                } & BaseStoryObject<Args, StoryFnReturnType>;

                                                                                                                                                                                                                                                                                  type BaseStoryObject

                                                                                                                                                                                                                                                                                  type BaseStoryObject<Args, StoryFnReturnType> = {
                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                  * Override the display name in the UI
                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                  storyName?: string;
                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                    type ClientApiReturnFn

                                                                                                                                                                                                                                                                                    type ClientApiReturnFn<StoryFnReturnType = unknown> = (
                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                    ) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                                                                                                                                      type Comparator

                                                                                                                                                                                                                                                                                      type Comparator<T> = ((a: T, b: T) => boolean) | ((a: T, b: T) => number);

                                                                                                                                                                                                                                                                                        type DecoratorFunction

                                                                                                                                                                                                                                                                                        type DecoratorFunction<StoryFnReturnType = unknown> = DecoratorFunctionForFramework<
                                                                                                                                                                                                                                                                                        ReturnTypeFramework<StoryFnReturnType>
                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                          type LegacyStoryFn

                                                                                                                                                                                                                                                                                          type LegacyStoryFn<ReturnType = unknown> = LegacyStoryFnForFramework<
                                                                                                                                                                                                                                                                                          ReturnTypeFramework<ReturnType>
                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                            type Loadable

                                                                                                                                                                                                                                                                                            type Loadable = RequireContext | [RequireContext] | LoadFn;

                                                                                                                                                                                                                                                                                              type Loader

                                                                                                                                                                                                                                                                                              type Loader = (api: API) => void;

                                                                                                                                                                                                                                                                                                type LoaderFunction

                                                                                                                                                                                                                                                                                                type LoaderFunction = LoaderFunctionForFramework<ReturnTypeFramework<unknown>>;

                                                                                                                                                                                                                                                                                                  type MakeDecoratorResult

                                                                                                                                                                                                                                                                                                  type MakeDecoratorResult = (...args: any) => any;

                                                                                                                                                                                                                                                                                                    type PartialStoryFn

                                                                                                                                                                                                                                                                                                    type PartialStoryFn<ReturnType = unknown> = PartialStoryFnForFramework<
                                                                                                                                                                                                                                                                                                    ReturnTypeFramework<ReturnType>
                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                      type StoryContext

                                                                                                                                                                                                                                                                                                      type StoryContext = StoryContextForFramework<AnyFramework>;

                                                                                                                                                                                                                                                                                                        type StoryContextUpdate

                                                                                                                                                                                                                                                                                                        type StoryContextUpdate = Partial<StoryContext>;

                                                                                                                                                                                                                                                                                                          type StoryFn

                                                                                                                                                                                                                                                                                                          type StoryFn<ReturnType = unknown> = StoryFnForFramework<
                                                                                                                                                                                                                                                                                                          ReturnTypeFramework<ReturnType>
                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                            type StorySortComparator

                                                                                                                                                                                                                                                                                                            type StorySortComparator = Comparator<[StoryId, any, Parameters, Parameters]>;

                                                                                                                                                                                                                                                                                                              type StorySortComparatorV7

                                                                                                                                                                                                                                                                                                              type StorySortComparatorV7 = Comparator<StoryIndexEntry>;

                                                                                                                                                                                                                                                                                                                type StorySortMethod

                                                                                                                                                                                                                                                                                                                type StorySortMethod = 'configure' | 'alphabetical';

                                                                                                                                                                                                                                                                                                                  type StorySortParameter

                                                                                                                                                                                                                                                                                                                  type StorySortParameter = StorySortComparator | StorySortObjectParameter;

                                                                                                                                                                                                                                                                                                                    type StorySortParameterV7

                                                                                                                                                                                                                                                                                                                    type StorySortParameterV7 = StorySortComparatorV7 | StorySortObjectParameter;

                                                                                                                                                                                                                                                                                                                      type StoryWrapper

                                                                                                                                                                                                                                                                                                                      type StoryWrapper = (
                                                                                                                                                                                                                                                                                                                      storyFn: LegacyStoryFn,
                                                                                                                                                                                                                                                                                                                      context: StoryContext,
                                                                                                                                                                                                                                                                                                                      settings: WrapperSettings
                                                                                                                                                                                                                                                                                                                      ) => any;

                                                                                                                                                                                                                                                                                                                        type Types

                                                                                                                                                                                                                                                                                                                        type Types = types | string;

                                                                                                                                                                                                                                                                                                                          Package Files (6)

                                                                                                                                                                                                                                                                                                                          Dependencies (11)

                                                                                                                                                                                                                                                                                                                          Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                          No dev dependencies.

                                                                                                                                                                                                                                                                                                                          Peer Dependencies (2)

                                                                                                                                                                                                                                                                                                                          Badge

                                                                                                                                                                                                                                                                                                                          To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                          You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@storybook/addons.

                                                                                                                                                                                                                                                                                                                          • Markdown
                                                                                                                                                                                                                                                                                                                            [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@storybook/addons)
                                                                                                                                                                                                                                                                                                                          • HTML
                                                                                                                                                                                                                                                                                                                            <a href="https://www.jsdocs.io/package/@storybook/addons"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>