• Version 6.3.7
  • Published
  • 2.52 MB
  • 24 dependencies
  • MIT license


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


Core Storybook Components







Type Aliases


variable A

const A: any;

    variable ActionBar

    const ActionBar: any;

      variable ArgsTable

      const ArgsTable: any;
      • Display the props for a component as a props table. Each row is a collection of ArgDefs, usually derived from docgen info for the component.

      variable ArrayControl

      const ArrayControl: any;

        variable Badge

        const Badge: any;

          variable Bar

          const Bar: any;

            variable Blockquote

            const Blockquote: any;

              variable BooleanControl

              const BooleanControl: any;

                variable Button

                const Button: any;

                  variable ColorItem

                  const ColorItem: any;
                  • A single color row your styleguide showing title, subtitle and one or more colors, used as a child of ColorPalette.

                  variable ColorPalette

                  const ColorPalette: any;
                  • Styleguide documentation for colors, including names, captions, and color swatches, all specified as ColorItem children of this wrapper component.

                  variable components

                  const components: {
                  h1: any;
                  h2: any;
                  h3: any;
                  h4: any;
                  h5: any;
                  h6: any;
                  pre: any;
                  a: any;
                  hr: any;
                  dl: any;
                  blockquote: any;
                  table: any;
                  img: any;
                  div: any;
                  span: any;
                  li: any;
                  ul: any;
                  ol: any;
                  p: any;
                  code: ({ className, children, ...props }: any) => any;
                  tt: any;
                  resetwrapper: any;

                    variable DateControl

                    const DateControl: any;

                      variable Description

                      const Description: any;
                      • A markdown description for a component, typically used to show the components docgen docs.

                      variable Div

                      const Div: any;

                        variable DL

                        const DL: any;

                          variable DocsContent

                          const DocsContent: any;

                            variable DocsPageWrapper

                            const DocsPageWrapper: any;

                              variable DocsWrapper

                              const DocsWrapper: any;

                                variable DocumentWrapper

                                const DocumentWrapper: any;

                                  variable FilesControl

                                  const FilesControl: any;

                                    variable FlexBar

                                    const FlexBar: any;

                                      variable Form

                                      const Form: any;

                                        variable H1

                                        const H1: any;

                                          variable H2

                                          const H2: any;

                                            variable H3

                                            const H3: any;

                                              variable H4

                                              const H4: any;

                                                variable H5

                                                const H5: any;

                                                  variable H6

                                                  const H6: any;

                                                    variable HR

                                                    const HR: any;

                                                      variable IconButton

                                                      const IconButton: any;

                                                        variable IconGallery

                                                        const IconGallery: any;
                                                        • Show a grid of icons, as specified by IconItem.

                                                        variable IconItem

                                                        const IconItem: any;
                                                        • An individual icon with a caption and an example (passed as children).

                                                        variable Icons

                                                        const Icons: any;

                                                          variable Img

                                                          const Img: any;

                                                            variable LI

                                                            const LI: any;
                                                              const Link: any;

                                                                variable Loader

                                                                const Loader: any;

                                                                  variable NumberControl

                                                                  const NumberControl: any;

                                                                    variable ObjectControl

                                                                    const ObjectControl: any;

                                                                      variable OL

                                                                      const OL: any;

                                                                        variable OptionsControl

                                                                        const OptionsControl: any;

                                                                          variable P

                                                                          const P: any;

                                                                            variable Placeholder

                                                                            const Placeholder: any;

                                                                              variable Pre

                                                                              const Pre: any;

                                                                                variable Preview

                                                                                const Preview: any;
                                                                                • A preview component for showing one or more component Story items. The preview also shows the source for the component as a drop-down.

                                                                                variable RangeControl

                                                                                const RangeControl: any;

                                                                                  variable resetComponents

                                                                                  const resetComponents: Record<string, any>;

                                                                                    variable ResetWrapper

                                                                                    const ResetWrapper: any;
                                                                                    • This is a "local" reset to style subtrees with Storybook styles

                                                                                      We can't style individual elements (e.g. h1, h2, etc.) in here because the CSS specificity is too high, so those styles can too easily override child elements that are not expecting it.

                                                                                    variable ScrollArea

                                                                                    const ScrollArea: any;

                                                                                      variable Separator

                                                                                      const Separator: any;

                                                                                        variable Source

                                                                                        const Source: any;
                                                                                        • Syntax-highlighted source code for a component (or anything!)

                                                                                        variable Spaced

                                                                                        const Spaced: any;

                                                                                          variable Span

                                                                                          const Span: any;

                                                                                            variable Story

                                                                                            const Story: any;
                                                                                            • A story element, either rendered inline or in an iframe, with configurable height.

                                                                                            variable StorybookIcon

                                                                                            const StorybookIcon: any;
                                                                                              const StorybookLogo: any;

                                                                                                variable StyledSyntaxHighlighter

                                                                                                const StyledSyntaxHighlighter: any;

                                                                                                  variable Subtitle

                                                                                                  const Subtitle: any;

                                                                                                    variable Symbols

                                                                                                    const Symbols: any;

                                                                                                      variable TabBar

                                                                                                      const TabBar: any;

                                                                                                        variable TabbedArgsTable

                                                                                                        const TabbedArgsTable: any;

                                                                                                          variable TabButton

                                                                                                          const TabButton: any;

                                                                                                            variable Table

                                                                                                            const Table: any;

                                                                                                              variable TableWrapper

                                                                                                              const TableWrapper: any;

                                                                                                                variable Tabs

                                                                                                                const Tabs: any;

                                                                                                                  variable TabWrapper

                                                                                                                  const TabWrapper: any;

                                                                                                                    variable TextControl

                                                                                                                    const TextControl: any;

                                                                                                                      variable Title

                                                                                                                      const Title: any;
                                                                                                                        const TooltipLinkList: any;

                                                                                                                          variable TooltipMessage

                                                                                                                          const TooltipMessage: any;

                                                                                                                            variable TooltipNote

                                                                                                                            const TooltipNote: any;

                                                                                                                              variable TT

                                                                                                                              const TT: any;

                                                                                                                                variable Typeset

                                                                                                                                const Typeset: any;
                                                                                                                                • Convenient styleguide documentation showing examples of type with different sizes and weights and configurable sample text.

                                                                                                                                variable UL

                                                                                                                                const UL: any;

                                                                                                                                  variable Zoom

                                                                                                                                  const Zoom: { Element: typeof Element; IFrame: typeof IFrame };


                                                                                                                                    function AddonPanel

                                                                                                                                    AddonPanel: ({ active, children }: AddonPanelProps) => any;

                                                                                                                                      function Code

                                                                                                                                      Code: ({ className, children, ...props }: any) => any;

                                                                                                                                        function ColorControl

                                                                                                                                        ColorControl: (props: any) => any;

                                                                                                                                          function format

                                                                                                                                          format: (value: NumberValue) => string;

                                                                                                                                            function interleaveSeparators

                                                                                                                                            interleaveSeparators: (list: any[]) => any;

                                                                                                                                              function NoControlsWarning

                                                                                                                                              NoControlsWarning: () => any;

                                                                                                                                                function parse

                                                                                                                                                parse: (value: string) => number;

                                                                                                                                                  function SyntaxHighlighter

                                                                                                                                                  SyntaxHighlighter: (props: any) => any;

                                                                                                                                                    function WithTooltip

                                                                                                                                                    WithTooltip: (props: any) => any;

                                                                                                                                                      function WithTooltipPure

                                                                                                                                                      WithTooltipPure: (props: any) => any;


                                                                                                                                                        class IFrame

                                                                                                                                                        class IFrame extends Component<IFrameProps> {}

                                                                                                                                                          property iframe

                                                                                                                                                          iframe: any;

                                                                                                                                                            method componentDidMount

                                                                                                                                                            componentDidMount: () => void;

                                                                                                                                                              method render

                                                                                                                                                              render: () => any;

                                                                                                                                                                method setIframeBodyStyle

                                                                                                                                                                setIframeBodyStyle: (style: BodyStyle) => any;

                                                                                                                                                                  method shouldComponentUpdate

                                                                                                                                                                  shouldComponentUpdate: (nextProps: IFrameProps) => boolean;

                                                                                                                                                                    class TabsState

                                                                                                                                                                    class TabsState extends Component<TabsStateProps, TabsStateState> {}


                                                                                                                                                                      constructor(props: TabsStateProps);

                                                                                                                                                                        property defaultProps

                                                                                                                                                                        static defaultProps: TabsStateProps;

                                                                                                                                                                          property handlers

                                                                                                                                                                          handlers: { onSelect: (id: string) => void };

                                                                                                                                                                            method render

                                                                                                                                                                            render: () => any;


                                                                                                                                                                              interface Args

                                                                                                                                                                              interface Args {}

                                                                                                                                                                                index signature

                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                  interface ArgsTableErrorProps

                                                                                                                                                                                  interface ArgsTableErrorProps {}

                                                                                                                                                                                    property error

                                                                                                                                                                                    error: ArgsTableError;

                                                                                                                                                                                      interface ArgsTableRowProps

                                                                                                                                                                                      interface ArgsTableRowProps {}

                                                                                                                                                                                        property args

                                                                                                                                                                                        args?: Args;

                                                                                                                                                                                          property compact

                                                                                                                                                                                          compact?: boolean;

                                                                                                                                                                                            property inAddonPanel

                                                                                                                                                                                            inAddonPanel?: boolean;

                                                                                                                                                                                              property initialExpandedArgs

                                                                                                                                                                                              initialExpandedArgs?: boolean;

                                                                                                                                                                                                property resetArgs

                                                                                                                                                                                                resetArgs?: (argNames?: string[]) => void;

                                                                                                                                                                                                  property rows

                                                                                                                                                                                                  rows: ArgTypes;

                                                                                                                                                                                                    property sort

                                                                                                                                                                                                    sort?: SortType;

                                                                                                                                                                                                      property updateArgs

                                                                                                                                                                                                      updateArgs?: (args: Args) => void;

                                                                                                                                                                                                        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 ArrayConfig

                                                                                                                                                                                                                      interface ArrayConfig {}

                                                                                                                                                                                                                        property separator

                                                                                                                                                                                                                        separator?: string;

                                                                                                                                                                                                                          interface BooleanConfig

                                                                                                                                                                                                                          interface BooleanConfig {}

                                                                                                                                                                                                                            interface ColorConfig

                                                                                                                                                                                                                            interface ColorConfig {}

                                                                                                                                                                                                                              property presetColors

                                                                                                                                                                                                                              presetColors?: PresetColor[];

                                                                                                                                                                                                                                property startOpen

                                                                                                                                                                                                                                startOpen?: boolean;

                                                                                                                                                                                                                                  interface ControlProps

                                                                                                                                                                                                                                  interface ControlProps<T> {}

                                                                                                                                                                                                                                    property argType

                                                                                                                                                                                                                                    argType?: ArgType;

                                                                                                                                                                                                                                      property defaultValue

                                                                                                                                                                                                                                      defaultValue?: T;

                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                          property onBlur

                                                                                                                                                                                                                                          onBlur?: (evt: any) => void;

                                                                                                                                                                                                                                            property onChange

                                                                                                                                                                                                                                            onChange: (value: T) => T | void;

                                                                                                                                                                                                                                              property onFocus

                                                                                                                                                                                                                                              onFocus?: (evt: any) => void;

                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                value?: T;

                                                                                                                                                                                                                                                  interface DateConfig

                                                                                                                                                                                                                                                  interface DateConfig {}

                                                                                                                                                                                                                                                    interface DescriptionProps

                                                                                                                                                                                                                                                    interface DescriptionProps {}

                                                                                                                                                                                                                                                      property markdown

                                                                                                                                                                                                                                                      markdown: string;

                                                                                                                                                                                                                                                        interface DocsPageProps

                                                                                                                                                                                                                                                        interface DocsPageProps {}

                                                                                                                                                                                                                                                          property subtitle

                                                                                                                                                                                                                                                          subtitle?: string;

                                                                                                                                                                                                                                                            property title

                                                                                                                                                                                                                                                            title: string;

                                                                                                                                                                                                                                                              interface FilesControlProps

                                                                                                                                                                                                                                                              interface FilesControlProps extends ControlProps<string[]> {}

                                                                                                                                                                                                                                                                property accept

                                                                                                                                                                                                                                                                accept?: string;

                                                                                                                                                                                                                                                                  interface IconsProps

                                                                                                                                                                                                                                                                  interface IconsProps extends ComponentProps<typeof Svg> {}

                                                                                                                                                                                                                                                                    property icon

                                                                                                                                                                                                                                                                    icon?: IconKey;

                                                                                                                                                                                                                                                                      property symbol

                                                                                                                                                                                                                                                                      symbol?: IconKey;

                                                                                                                                                                                                                                                                        interface JsDocParam

                                                                                                                                                                                                                                                                        interface JsDocParam {}

                                                                                                                                                                                                                                                                          property description

                                                                                                                                                                                                                                                                          description?: string;

                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                              interface JsDocReturns

                                                                                                                                                                                                                                                                              interface JsDocReturns {}

                                                                                                                                                                                                                                                                                property description

                                                                                                                                                                                                                                                                                description?: string;

                                                                                                                                                                                                                                                                                  interface JsDocTags

                                                                                                                                                                                                                                                                                  interface JsDocTags {}

                                                                                                                                                                                                                                                                                    property params

                                                                                                                                                                                                                                                                                    params?: JsDocParam[];

                                                                                                                                                                                                                                                                                      property returns

                                                                                                                                                                                                                                                                                      returns?: JsDocReturns;

                                                                                                                                                                                                                                                                                        interface NormalizedOptionsConfig

                                                                                                                                                                                                                                                                                        interface NormalizedOptionsConfig {}

                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                          options: OptionsObject;

                                                                                                                                                                                                                                                                                            interface NumberConfig

                                                                                                                                                                                                                                                                                            interface NumberConfig {}

                                                                                                                                                                                                                                                                                              property max

                                                                                                                                                                                                                                                                                              max?: number;

                                                                                                                                                                                                                                                                                                property min

                                                                                                                                                                                                                                                                                                min?: number;

                                                                                                                                                                                                                                                                                                  property step

                                                                                                                                                                                                                                                                                                  step?: number;

                                                                                                                                                                                                                                                                                                    interface ObjectConfig

                                                                                                                                                                                                                                                                                                    interface ObjectConfig {}

                                                                                                                                                                                                                                                                                                      interface OptionsConfig

                                                                                                                                                                                                                                                                                                      interface OptionsConfig {}

                                                                                                                                                                                                                                                                                                        property labels

                                                                                                                                                                                                                                                                                                        labels: Record<any, string>;

                                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                                          options: Options;

                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                            type: OptionsControlType;

                                                                                                                                                                                                                                                                                                              interface PreviewProps

                                                                                                                                                                                                                                                                                                              interface PreviewProps {}

                                                                                                                                                                                                                                                                                                                property additionalActions

                                                                                                                                                                                                                                                                                                                additionalActions?: ActionItem[];

                                                                                                                                                                                                                                                                                                                  property className

                                                                                                                                                                                                                                                                                                                  className?: string;

                                                                                                                                                                                                                                                                                                                    property columns

                                                                                                                                                                                                                                                                                                                    columns?: number;

                                                                                                                                                                                                                                                                                                                      property isColumn

                                                                                                                                                                                                                                                                                                                      isColumn?: boolean;

                                                                                                                                                                                                                                                                                                                        property isExpanded

                                                                                                                                                                                                                                                                                                                        isExpanded?: boolean;

                                                                                                                                                                                                                                                                                                                          property withSource

                                                                                                                                                                                                                                                                                                                          withSource?: SourceProps;

                                                                                                                                                                                                                                                                                                                            property withToolbar

                                                                                                                                                                                                                                                                                                                            withToolbar?: boolean;

                                                                                                                                                                                                                                                                                                                              interface PropSummaryValue

                                                                                                                                                                                                                                                                                                                              interface PropSummaryValue {}

                                                                                                                                                                                                                                                                                                                                property detail

                                                                                                                                                                                                                                                                                                                                detail?: string;

                                                                                                                                                                                                                                                                                                                                  property required

                                                                                                                                                                                                                                                                                                                                  required?: boolean;

                                                                                                                                                                                                                                                                                                                                    property summary

                                                                                                                                                                                                                                                                                                                                    summary: string;

                                                                                                                                                                                                                                                                                                                                      interface SyntaxHighlighterProps

                                                                                                                                                                                                                                                                                                                                      interface SyntaxHighlighterProps {}

                                                                                                                                                                                                                                                                                                                                        property bordered

                                                                                                                                                                                                                                                                                                                                        bordered?: boolean;

                                                                                                                                                                                                                                                                                                                                          property className

                                                                                                                                                                                                                                                                                                                                          className?: string;

                                                                                                                                                                                                                                                                                                                                            property copyable

                                                                                                                                                                                                                                                                                                                                            copyable?: boolean;

                                                                                                                                                                                                                                                                                                                                              property format

                                                                                                                                                                                                                                                                                                                                              format?: boolean;

                                                                                                                                                                                                                                                                                                                                                property language

                                                                                                                                                                                                                                                                                                                                                language: string;

                                                                                                                                                                                                                                                                                                                                                  property padded

                                                                                                                                                                                                                                                                                                                                                  padded?: boolean;

                                                                                                                                                                                                                                                                                                                                                    property renderer

                                                                                                                                                                                                                                                                                                                                                    renderer?: (props: SyntaxHighlighterRendererProps) => React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                      interface SyntaxHighlighterRendererProps

                                                                                                                                                                                                                                                                                                                                                      interface SyntaxHighlighterRendererProps {}

                                                                                                                                                                                                                                                                                                                                                        property rows

                                                                                                                                                                                                                                                                                                                                                        rows: any[];

                                                                                                                                                                                                                                                                                                                                                          property stylesheet

                                                                                                                                                                                                                                                                                                                                                          stylesheet: string;

                                                                                                                                                                                                                                                                                                                                                            property useInlineStyles

                                                                                                                                                                                                                                                                                                                                                            useInlineStyles: boolean;

                                                                                                                                                                                                                                                                                                                                                              interface TabbedArgsTableProps

                                                                                                                                                                                                                                                                                                                                                              interface TabbedArgsTableProps {}

                                                                                                                                                                                                                                                                                                                                                                property sort

                                                                                                                                                                                                                                                                                                                                                                sort?: SortType;

                                                                                                                                                                                                                                                                                                                                                                  property tabs

                                                                                                                                                                                                                                                                                                                                                                  tabs: Record<string, ArgsTableProps>;

                                                                                                                                                                                                                                                                                                                                                                    interface TableAnnotation

                                                                                                                                                                                                                                                                                                                                                                    interface TableAnnotation {}

                                                                                                                                                                                                                                                                                                                                                                      property category

                                                                                                                                                                                                                                                                                                                                                                      category?: string;

                                                                                                                                                                                                                                                                                                                                                                        property defaultValue

                                                                                                                                                                                                                                                                                                                                                                        defaultValue?: PropDefaultValue;

                                                                                                                                                                                                                                                                                                                                                                          property jsDocTags

                                                                                                                                                                                                                                                                                                                                                                          jsDocTags?: JsDocTags;

                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                            type: PropType;

                                                                                                                                                                                                                                                                                                                                                                              interface TextConfig

                                                                                                                                                                                                                                                                                                                                                                              interface TextConfig {}

                                                                                                                                                                                                                                                                                                                                                                                interface TypesetProps

                                                                                                                                                                                                                                                                                                                                                                                interface TypesetProps {}

                                                                                                                                                                                                                                                                                                                                                                                  property fontFamily

                                                                                                                                                                                                                                                                                                                                                                                  fontFamily?: string;

                                                                                                                                                                                                                                                                                                                                                                                    property fontSizes

                                                                                                                                                                                                                                                                                                                                                                                    fontSizes: string[];

                                                                                                                                                                                                                                                                                                                                                                                      property fontWeight

                                                                                                                                                                                                                                                                                                                                                                                      fontWeight?: number;

                                                                                                                                                                                                                                                                                                                                                                                        property sampleText

                                                                                                                                                                                                                                                                                                                                                                                        sampleText?: string;


                                                                                                                                                                                                                                                                                                                                                                                          enum ArgsTableError

                                                                                                                                                                                                                                                                                                                                                                                          enum ArgsTableError {
                                                                                                                                                                                                                                                                                                                                                                                          NO_COMPONENT = 'No component found.',
                                                                                                                                                                                                                                                                                                                                                                                          ARGS_UNSUPPORTED = 'Args unsupported. See Args documentation for your framework.',

                                                                                                                                                                                                                                                                                                                                                                                            member ARGS_UNSUPPORTED

                                                                                                                                                                                                                                                                                                                                                                                            ARGS_UNSUPPORTED = 'Args unsupported. See Args documentation for your framework.'

                                                                                                                                                                                                                                                                                                                                                                                              member NO_COMPONENT

                                                                                                                                                                                                                                                                                                                                                                                              NO_COMPONENT = 'No component found.'

                                                                                                                                                                                                                                                                                                                                                                                                enum SourceError

                                                                                                                                                                                                                                                                                                                                                                                                enum SourceError {
                                                                                                                                                                                                                                                                                                                                                                                                NO_STORY = 'There\u2019s no story here.',
                                                                                                                                                                                                                                                                                                                                                                                                SOURCE_UNAVAILABLE = 'Oh no! The source is not available.',

                                                                                                                                                                                                                                                                                                                                                                                                  member NO_STORY

                                                                                                                                                                                                                                                                                                                                                                                                  NO_STORY = 'There\u2019s no story here.'

                                                                                                                                                                                                                                                                                                                                                                                                    member SOURCE_UNAVAILABLE

                                                                                                                                                                                                                                                                                                                                                                                                    SOURCE_UNAVAILABLE = 'Oh no! The source is not available.'

                                                                                                                                                                                                                                                                                                                                                                                                      enum StoryError

                                                                                                                                                                                                                                                                                                                                                                                                      enum StoryError {
                                                                                                                                                                                                                                                                                                                                                                                                      NO_STORY = 'No component or story to display',

                                                                                                                                                                                                                                                                                                                                                                                                        member NO_STORY

                                                                                                                                                                                                                                                                                                                                                                                                        NO_STORY = 'No component or story to display'

                                                                                                                                                                                                                                                                                                                                                                                                          Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                          type ArgsTableProps

                                                                                                                                                                                                                                                                                                                                                                                                          type ArgsTableProps = ArgsTableRowProps | ArgsTableErrorProps;

                                                                                                                                                                                                                                                                                                                                                                                                            type ArrayProps

                                                                                                                                                                                                                                                                                                                                                                                                            type ArrayProps = ControlProps<ArrayValue> & ArrayConfig;

                                                                                                                                                                                                                                                                                                                                                                                                              type ArrayValue

                                                                                                                                                                                                                                                                                                                                                                                                              type ArrayValue = string[] | readonly string[];

                                                                                                                                                                                                                                                                                                                                                                                                                type BooleanProps

                                                                                                                                                                                                                                                                                                                                                                                                                type BooleanProps = ControlProps<BooleanValue> & BooleanConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                  type BooleanValue

                                                                                                                                                                                                                                                                                                                                                                                                                  type BooleanValue = boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                    type ColorProps

                                                                                                                                                                                                                                                                                                                                                                                                                    type ColorProps = ControlProps<ColorValue> & ColorConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                      type ColorValue

                                                                                                                                                                                                                                                                                                                                                                                                                      type ColorValue = string;

                                                                                                                                                                                                                                                                                                                                                                                                                        type Control

                                                                                                                                                                                                                                                                                                                                                                                                                        type Control =
                                                                                                                                                                                                                                                                                                                                                                                                                        | ArrayConfig
                                                                                                                                                                                                                                                                                                                                                                                                                        | BooleanConfig
                                                                                                                                                                                                                                                                                                                                                                                                                        | ColorConfig
                                                                                                                                                                                                                                                                                                                                                                                                                        | DateConfig
                                                                                                                                                                                                                                                                                                                                                                                                                        | NumberConfig
                                                                                                                                                                                                                                                                                                                                                                                                                        | ObjectConfig
                                                                                                                                                                                                                                                                                                                                                                                                                        | OptionsConfig
                                                                                                                                                                                                                                                                                                                                                                                                                        | RangeConfig
                                                                                                                                                                                                                                                                                                                                                                                                                        | TextConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                          type Controls

                                                                                                                                                                                                                                                                                                                                                                                                                          type Controls = Record<string, Control>;

                                                                                                                                                                                                                                                                                                                                                                                                                            type ControlType

                                                                                                                                                                                                                                                                                                                                                                                                                            type ControlType =
                                                                                                                                                                                                                                                                                                                                                                                                                            | 'array'
                                                                                                                                                                                                                                                                                                                                                                                                                            | 'boolean'
                                                                                                                                                                                                                                                                                                                                                                                                                            | 'color'
                                                                                                                                                                                                                                                                                                                                                                                                                            | 'date'
                                                                                                                                                                                                                                                                                                                                                                                                                            | 'number'
                                                                                                                                                                                                                                                                                                                                                                                                                            | 'range'
                                                                                                                                                                                                                                                                                                                                                                                                                            | 'object'
                                                                                                                                                                                                                                                                                                                                                                                                                            | OptionsControlType
                                                                                                                                                                                                                                                                                                                                                                                                                            | 'text';

                                                                                                                                                                                                                                                                                                                                                                                                                              type DateProps

                                                                                                                                                                                                                                                                                                                                                                                                                              type DateProps = ControlProps<DateValue> & DateConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                type DateValue

                                                                                                                                                                                                                                                                                                                                                                                                                                type DateValue = Date | number;

                                                                                                                                                                                                                                                                                                                                                                                                                                  type NumberValue

                                                                                                                                                                                                                                                                                                                                                                                                                                  type NumberValue = number;

                                                                                                                                                                                                                                                                                                                                                                                                                                    type ObjectProps

                                                                                                                                                                                                                                                                                                                                                                                                                                    type ObjectProps = ControlProps<ObjectValue> &
                                                                                                                                                                                                                                                                                                                                                                                                                                    ObjectConfig & {
                                                                                                                                                                                                                                                                                                                                                                                                                                    theme: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                      type ObjectValue

                                                                                                                                                                                                                                                                                                                                                                                                                                      type ObjectValue = any;

                                                                                                                                                                                                                                                                                                                                                                                                                                        type Options

                                                                                                                                                                                                                                                                                                                                                                                                                                        type Options = OptionsArray | OptionsObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                          type OptionsArray

                                                                                                                                                                                                                                                                                                                                                                                                                                          type OptionsArray = any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                            type OptionsControlType

                                                                                                                                                                                                                                                                                                                                                                                                                                            type OptionsControlType =
                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'radio'
                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'inline-radio'
                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'check'
                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'inline-check'
                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'select'
                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'multi-select';

                                                                                                                                                                                                                                                                                                                                                                                                                                              type OptionsMultiSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                              type OptionsMultiSelection = any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                type OptionsObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                type OptionsObject = Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type OptionsProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type OptionsProps = ControlProps<OptionsSelection> & OptionsConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type OptionsSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type OptionsSelection = OptionsSingleSelection | OptionsMultiSelection;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type OptionsSingleSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type OptionsSingleSelection = any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type PresetColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type PresetColor =
                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ColorValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        color: ColorValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        title?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PropDefaultValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PropDefaultValue = PropSummaryValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PropType

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PropType = PropSummaryValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RangeConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RangeConfig = NumberConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SortType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SortType = 'alpha' | 'requiredFirst' | 'none';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SourceProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SourceProps = SourceErrorProps & SourceCodeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TextProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TextProps = ControlProps<TextValue | undefined> & TextConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TextValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TextValue = string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (52)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (24)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (2)


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

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