@storybook/addons

  • Version 6.2.9
  • Published
  • 80 kB
  • 9 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: (
    applyDecorators: (getStory: StoryGetter, decorators: Decorator[]) => StoryGetter
    ) => (
    getStory: StoryGetter,
    decorators: Decorator[]
    ) => (context: StoryContext) => any;

      function isSupportedType

      isSupportedType: (type: Types) => boolean;

        function makeDecorator

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

          function mockChannel

          mockChannel: () => any;

            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: () => StoryContext;

                                  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: () => any;

                                            property getConfig

                                            getConfig: () => Config;

                                              property getElements

                                              getElements: (type: Types) => Collection;

                                                property hasChannel

                                                hasChannel: () => boolean;

                                                  property loadAddons

                                                  loadAddons: (api: any) => void;

                                                    property ready

                                                    ready: () => Promise<Channel>;

                                                      property register

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

                                                        property setChannel

                                                        setChannel: (channel: any) => void;

                                                          property setConfig

                                                          setConfig: (value: Config) => void;

                                                            class HooksContext

                                                            class HooksContext {}

                                                              constructor

                                                              constructor();

                                                                property currentContext

                                                                currentContext: StoryContext;

                                                                  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: () => 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 Args

                                                                                                                                      interface Args {}

                                                                                                                                        index signature

                                                                                                                                        [key: string]: any;

                                                                                                                                          interface ArgType

                                                                                                                                          interface ArgType {}

                                                                                                                                            property defaultValue

                                                                                                                                            defaultValue?: any;

                                                                                                                                              property description

                                                                                                                                              description?: string;

                                                                                                                                                property name

                                                                                                                                                name?: string;

                                                                                                                                                  index signature

                                                                                                                                                  [key: string]: any;

                                                                                                                                                    interface ArgTypes

                                                                                                                                                    interface ArgTypes {}

                                                                                                                                                      index signature

                                                                                                                                                      [key: string]: ArgType;

                                                                                                                                                        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;
                                                                                                                                                          • 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)

                                                                                                                                                          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 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.

                                                                                                                                                              Example 1

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

                                                                                                                                                              See Also

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

                                                                                                                                                            interface BaseStory

                                                                                                                                                            interface BaseStory<Args, StoryFnReturnType> {}

                                                                                                                                                              property storyName

                                                                                                                                                              storyName?: string;
                                                                                                                                                              • Override the display name in the UI

                                                                                                                                                              call signature

                                                                                                                                                              (args: Args, context: StoryContext): StoryFnReturnType;

                                                                                                                                                                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: DecoratorFunction<StoryFnReturnType>
                                                                                                                                                                          ) => StoryApi<StoryFnReturnType>;

                                                                                                                                                                            method addParameters

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

                                                                                                                                                                              method storiesOf

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

                                                                                                                                                                                interface Collection

                                                                                                                                                                                interface Collection {}

                                                                                                                                                                                  index signature

                                                                                                                                                                                  [key: string]: Addon;

                                                                                                                                                                                    interface Config

                                                                                                                                                                                    interface Config {}

                                                                                                                                                                                      property theme

                                                                                                                                                                                      theme?: ThemeVars;

                                                                                                                                                                                        index signature

                                                                                                                                                                                        [key: string]: any;

                                                                                                                                                                                          interface EventMap

                                                                                                                                                                                          interface EventMap {}

                                                                                                                                                                                            index signature

                                                                                                                                                                                            [eventId: string]: Listener;

                                                                                                                                                                                              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 StoryIdentifier

                                                                                                                                                                                                                                        interface StoryIdentifier {}

                                                                                                                                                                                                                                          property id

                                                                                                                                                                                                                                          id: StoryId;

                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                            kind: StoryKind;

                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                              name: StoryName;

                                                                                                                                                                                                                                                interface StorySortObjectParameter

                                                                                                                                                                                                                                                interface StorySortObjectParameter {}

                                                                                                                                                                                                                                                  property locales

                                                                                                                                                                                                                                                  locales?: string;

                                                                                                                                                                                                                                                    property method

                                                                                                                                                                                                                                                    method?: StorySortMethod;

                                                                                                                                                                                                                                                      property order

                                                                                                                                                                                                                                                      order?: any[];

                                                                                                                                                                                                                                                        interface WrapperSettings

                                                                                                                                                                                                                                                        interface WrapperSettings {}

                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                          options: OptionsParameter;

                                                                                                                                                                                                                                                            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> = (a?: Args, p?: StoryContext) => ReturnType;

                                                                                                                                                                                                                                                                              type BaseDecorators

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

                                                                                                                                                                                                                                                                                type ClientApiReturnFn

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

                                                                                                                                                                                                                                                                                  type Comparator

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

                                                                                                                                                                                                                                                                                    type DecorateStoryFunction

                                                                                                                                                                                                                                                                                    type DecorateStoryFunction<StoryFnReturnType = unknown> = (
                                                                                                                                                                                                                                                                                    storyFn: StoryFn<StoryFnReturnType>,
                                                                                                                                                                                                                                                                                    decorators: DecoratorFunction<StoryFnReturnType>[]
                                                                                                                                                                                                                                                                                    ) => StoryFn<StoryFnReturnType>;

                                                                                                                                                                                                                                                                                      type DecoratorFunction

                                                                                                                                                                                                                                                                                      type DecoratorFunction<StoryFnReturnType = unknown> = (
                                                                                                                                                                                                                                                                                      fn: StoryFn<StoryFnReturnType>,
                                                                                                                                                                                                                                                                                      c: StoryContext
                                                                                                                                                                                                                                                                                      ) => ReturnType<StoryFn<StoryFnReturnType>>;

                                                                                                                                                                                                                                                                                        type LegacyStoryFn

                                                                                                                                                                                                                                                                                        type LegacyStoryFn<ReturnType = unknown> = (p?: StoryContext) => ReturnType;

                                                                                                                                                                                                                                                                                          type Loadable

                                                                                                                                                                                                                                                                                          type Loadable = RequireContext | [RequireContext] | LoadFn;

                                                                                                                                                                                                                                                                                            type Loader

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

                                                                                                                                                                                                                                                                                              type LoaderFunction

                                                                                                                                                                                                                                                                                              type LoaderFunction = (c: StoryContext) => Promise<Record<string, any>>;

                                                                                                                                                                                                                                                                                                type MakeDecoratorResult

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

                                                                                                                                                                                                                                                                                                  type StoryContext

                                                                                                                                                                                                                                                                                                  type StoryContext = StoryIdentifier & {
                                                                                                                                                                                                                                                                                                  [key: string]: any;
                                                                                                                                                                                                                                                                                                  parameters: Parameters;
                                                                                                                                                                                                                                                                                                  args: Args;
                                                                                                                                                                                                                                                                                                  argTypes: ArgTypes;
                                                                                                                                                                                                                                                                                                  globals: Args;
                                                                                                                                                                                                                                                                                                  hooks?: HooksContext;
                                                                                                                                                                                                                                                                                                  viewMode?: ViewMode;
                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                    type StoryFn

                                                                                                                                                                                                                                                                                                    type StoryFn<ReturnType = unknown> =
                                                                                                                                                                                                                                                                                                    | LegacyStoryFn<ReturnType>
                                                                                                                                                                                                                                                                                                    | ArgsStoryFn<ReturnType>;

                                                                                                                                                                                                                                                                                                      type StoryGetter

                                                                                                                                                                                                                                                                                                      type StoryGetter = (context: StoryContext) => any;

                                                                                                                                                                                                                                                                                                        type StoryId

                                                                                                                                                                                                                                                                                                        type StoryId = string;

                                                                                                                                                                                                                                                                                                          type StoryKind

                                                                                                                                                                                                                                                                                                          type StoryKind = string;

                                                                                                                                                                                                                                                                                                            type StoryName

                                                                                                                                                                                                                                                                                                            type StoryName = string;

                                                                                                                                                                                                                                                                                                              type StorySortComparator

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

                                                                                                                                                                                                                                                                                                                type StorySortMethod

                                                                                                                                                                                                                                                                                                                type StorySortMethod = 'configure' | 'alphabetical';

                                                                                                                                                                                                                                                                                                                  type StorySortParameter

                                                                                                                                                                                                                                                                                                                  type StorySortParameter = StorySortComparator | StorySortObjectParameter;

                                                                                                                                                                                                                                                                                                                    type StoryWrapper

                                                                                                                                                                                                                                                                                                                    type StoryWrapper = (
                                                                                                                                                                                                                                                                                                                    getStory: StoryGetter,
                                                                                                                                                                                                                                                                                                                    context: StoryContext,
                                                                                                                                                                                                                                                                                                                    settings: WrapperSettings
                                                                                                                                                                                                                                                                                                                    ) => any;

                                                                                                                                                                                                                                                                                                                      type Types

                                                                                                                                                                                                                                                                                                                      type Types = types | string;

                                                                                                                                                                                                                                                                                                                        type ViewMode

                                                                                                                                                                                                                                                                                                                        type ViewMode = 'story' | 'docs';

                                                                                                                                                                                                                                                                                                                          Package Files (6)

                                                                                                                                                                                                                                                                                                                          Dependencies (9)

                                                                                                                                                                                                                                                                                                                          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>