@storybook/components

  • Version 6.2.9
  • Published
  • 1.88 MB
  • 24 dependencies
  • MIT license

Install

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

Overview

Core Storybook Components

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

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, ...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 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 };

                                                                                                                                  Functions

                                                                                                                                  function AddonPanel

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

                                                                                                                                    function Code

                                                                                                                                    Code: ({ className, ...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;

                                                                                                                                                      Classes

                                                                                                                                                      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

                                                                                                                                                                    constructor(props: TabsStateProps);

                                                                                                                                                                      property defaultProps

                                                                                                                                                                      static defaultProps: TabsStateProps;

                                                                                                                                                                        property handlers

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

                                                                                                                                                                          method render

                                                                                                                                                                          render: () => any;

                                                                                                                                                                            Interfaces

                                                                                                                                                                            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;

                                                                                                                                                                                                                                                                                                                                                                                        Enums

                                                                                                                                                                                                                                                                                                                                                                                        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)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Badge

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@storybook/components)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 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>