• Version 11.1.8
  • Published
  • 430 kB
  • 62 dependencies
  • MIT license


npm i react-styleguidist
yarn add react-styleguidist
pnpm add react-styleguidist


React components style guide generator



Type Aliases



interface BaseComponent

interface BaseComponent {}

    property description

    description?: string;

      property exampleMode

      exampleMode?: ExpandMode;

        property filepath

        filepath?: string;

          property hasExamples

          hasExamples?: boolean;

            property href

            href?: string;

              property name

              name?: string;

                property pathLine

                pathLine?: string;

                  property slug

                  slug?: string;

                    property usageMode

                    usageMode?: ExpandMode;

                      interface BaseSection

                      interface BaseSection {}

                        property description

                        description?: string;

                          property exampleMode

                          exampleMode?: ExpandMode;

                            property expand

                            expand?: boolean;

                              property external

                              external?: boolean;

                                property href

                                href?: string;

                                  property ignore

                                  ignore?: string | string[];

                                    property name

                                    name?: string;

                                      property sectionDepth

                                      sectionDepth?: number;

                                        property slug

                                        slug?: string;

                                          property usageMode

                                          usageMode?: ExpandMode;

                                            interface CodeExample

                                            interface CodeExample {}

                                              property content

                                              content: string;

                                                property lang

                                                lang?: string | null;

                                                  property settings

                                                  settings?: Record<string, any>;

                                                    property type

                                                    type: 'code';

                                                      interface Component

                                                      interface Component extends BaseComponent {}

                                                        property metadata

                                                        metadata?: {
                                                        tags?: string[];

                                                          property module

                                                          module?: number;

                                                            property props

                                                            props?: {
                                                            displayName?: string;
                                                            visibleName?: string;
                                                            description?: string;
                                                            methods?: MethodDescriptor[];
                                                            props?: PropDescriptor[];
                                                            tags?: TagProps;
                                                            example?: Example[];
                                                            examples?: Example[];

                                                              property visibleName

                                                              visibleName?: string;

                                                                interface ConfigSection

                                                                interface ConfigSection extends BaseSection {}
                                                                • Used in the config file and at the early stages of processing in schema/config.ts this is the type that is used

                                                                property components

                                                                components?: string | string[] | (() => string[]);

                                                                  property content

                                                                  content?: string;

                                                                    property sections

                                                                    sections?: ConfigSection[];

                                                                      interface LoaderComponent

                                                                      interface LoaderComponent extends BaseComponent {}

                                                                        property metadata

                                                                        metadata: RequireItResult | Record<string, unknown>;

                                                                          property module

                                                                          module: RequireItResult;

                                                                            property props

                                                                            props: RequireItResult;

                                                                              interface LoaderSection

                                                                              interface LoaderSection extends BaseSection {}
                                                                              • Type returned when sections are transformed to their webpack loadable equivalents

                                                                              property components

                                                                              components: LoaderComponent[];

                                                                                property content

                                                                                content?: RequireItResult | MarkdownExample;

                                                                                  property sections

                                                                                  sections: LoaderSection[];

                                                                                    property slug

                                                                                    slug?: string;

                                                                                      interface MarkdownExample

                                                                                      interface MarkdownExample {}

                                                                                        property content

                                                                                        content: string;

                                                                                          property settings

                                                                                          settings?: Record<string, any>;

                                                                                            property type

                                                                                            type: 'markdown';

                                                                                              interface MethodWithDocblock

                                                                                              interface MethodWithDocblock extends MethodDescriptor {}

                                                                                                property docblock

                                                                                                docblock: string;

                                                                                                  interface ProcessedSection

                                                                                                  interface ProcessedSection extends BaseSection {}
                                                                                                    externalLink?: boolean;

                                                                                                      property filepath

                                                                                                      filepath?: string;

                                                                                                        property href

                                                                                                        href?: string;

                                                                                                          property visibleName

                                                                                                          visibleName?: string;

                                                                                                            interface ProcessedStyleguidistConfig

                                                                                                            interface ProcessedStyleguidistConfig extends BaseStyleguidistConfig {}

                                                                                                              property sections

                                                                                                              sections: Section[];

                                                                                                                property styles

                                                                                                                styles: ((th: Theme) => Styles) | Styles;

                                                                                                                  property theme

                                                                                                                  theme: RecursivePartial<Theme>;

                                                                                                                    interface PropsObject

                                                                                                                    interface PropsObject extends Omit<TempPropsObject, 'props'> {}

                                                                                                                      property examples

                                                                                                                      examples?: RequireItResult | null;

                                                                                                                        property props

                                                                                                                        props?: Record<string, PropDescriptor> | PropDescriptor[];

                                                                                                                          interface RequireItResult

                                                                                                                          interface RequireItResult {}

                                                                                                                            property require

                                                                                                                            require: string;

                                                                                                                              method toAST

                                                                                                                              toAST: () => ASTNode;

                                                                                                                                interface RuntimeCodeExample

                                                                                                                                interface RuntimeCodeExample extends CodeExample {}

                                                                                                                                  method evalInContext

                                                                                                                                  evalInContext: (a: string) => () => any;

                                                                                                                                    interface SanitizedStyleguidistConfig

                                                                                                                                    interface SanitizedStyleguidistConfig extends BaseStyleguidistConfig {}

                                                                                                                                      property sections

                                                                                                                                      sections: ConfigSection[];

                                                                                                                                        interface Section

                                                                                                                                        interface Section extends ProcessedSection {}
                                                                                                                                        • Section used on the client in javascript It is the output of the function client/utils/processSection

                                                                                                                                        property components

                                                                                                                                        components?: Component[];

                                                                                                                                          property content

                                                                                                                                          content?: Example[] | string;

                                                                                                                                            property sections

                                                                                                                                            sections?: Section[];

                                                                                                                                              interface StyleguidistConfig

                                                                                                                                              interface StyleguidistConfig
                                                                                                                                              extends RecursivePartial<Omit<SanitizedStyleguidistConfig, 'defaultExample'>> {}
                                                                                                                                              • definition of the config object where everything is optional note that teh default example can be both a string and a boolean but ends up only being a string after sanitizing

                                                                                                                                              property defaultExample

                                                                                                                                              defaultExample?: string | boolean;

                                                                                                                                                interface StyleguidistLoaderContext

                                                                                                                                                interface StyleguidistLoaderContext extends loader.LoaderContext {}

                                                                                                                                                  interface TempPropsObject

                                                                                                                                                  interface TempPropsObject extends DocumentationObject {}

                                                                                                                                                    property displayName

                                                                                                                                                    displayName: string;

                                                                                                                                                      property doclets

                                                                                                                                                      doclets: Record<string, any>;

                                                                                                                                                        property example

                                                                                                                                                        example?: RequireItResult | null;

                                                                                                                                                          property methods

                                                                                                                                                          methods?: MethodWithDocblock[];

                                                                                                                                                            property visibleName

                                                                                                                                                            visibleName?: string;

                                                                                                                                                              interface Theme

                                                                                                                                                              interface Theme {}
                                                                                                                                                              • When the theme is to be used in a component, it will have all it's values set. None of those declarations should be optional

                                                                                                                                                              property borderRadius

                                                                                                                                                              borderRadius: number;

                                                                                                                                                                property buttonTextTransform

                                                                                                                                                                buttonTextTransform: string;

                                                                                                                                                                  property color

                                                                                                                                                                  color: {
                                                                                                                                                                  base: string;
                                                                                                                                                                  light: string;
                                                                                                                                                                  lightest: string;
                                                                                                                                                                  link: string;
                                                                                                                                                                  linkHover: string;
                                                                                                                                                                  focus: string;
                                                                                                                                                                  border: string;
                                                                                                                                                                  name: string;
                                                                                                                                                                  type: string;
                                                                                                                                                                  error: string;
                                                                                                                                                                  baseBackground: string;
                                                                                                                                                                  codeBackground: string;
                                                                                                                                                                  sidebarBackground: string;
                                                                                                                                                                  ribbonBackground: string;
                                                                                                                                                                  ribbonText: string;
                                                                                                                                                                  codeBase: string;
                                                                                                                                                                  codeComment: string;
                                                                                                                                                                  codePunctuation: string;
                                                                                                                                                                  codeProperty: string;
                                                                                                                                                                  codeDeleted: string;
                                                                                                                                                                  codeString: string;
                                                                                                                                                                  codeInserted: string;
                                                                                                                                                                  codeOperator: string;
                                                                                                                                                                  codeKeyword: string;
                                                                                                                                                                  codeFunction: string;
                                                                                                                                                                  codeVariable: string;

                                                                                                                                                                    property fontFamily

                                                                                                                                                                    fontFamily: {
                                                                                                                                                                    base: string[];
                                                                                                                                                                    monospace: string[];

                                                                                                                                                                      property fontSize

                                                                                                                                                                      fontSize: {
                                                                                                                                                                      base: number;
                                                                                                                                                                      text: number;
                                                                                                                                                                      small: number;
                                                                                                                                                                      h1: number;
                                                                                                                                                                      h2: number;
                                                                                                                                                                      h3: number;
                                                                                                                                                                      h4: number;
                                                                                                                                                                      h5: number;
                                                                                                                                                                      h6: number;

                                                                                                                                                                        property maxWidth

                                                                                                                                                                        maxWidth: number;

                                                                                                                                                                          property mq

                                                                                                                                                                          mq: {
                                                                                                                                                                          small: string;

                                                                                                                                                                            property sidebarWidth

                                                                                                                                                                            sidebarWidth: number;

                                                                                                                                                                              property space

                                                                                                                                                                              space: number[];

                                                                                                                                                                                property spaceFactor

                                                                                                                                                                                spaceFactor: number;

                                                                                                                                                                                  interface TOCItem

                                                                                                                                                                                  interface TOCItem extends ProcessedSection {}
                                                                                                                                                                                  • Item of the Table Of Contents used in ComponentsList TableOfContent filterSectionByName

                                                                                                                                                                                  property components

                                                                                                                                                                                  components?: TOCItem[];

                                                                                                                                                                                    property content

                                                                                                                                                                                    content?: React.ReactNode;

                                                                                                                                                                                      property forcedOpen

                                                                                                                                                                                      forcedOpen?: boolean;

                                                                                                                                                                                        property heading

                                                                                                                                                                                        heading?: boolean;

                                                                                                                                                                                          property initialOpen

                                                                                                                                                                                          initialOpen?: boolean;

                                                                                                                                                                                            property sections

                                                                                                                                                                                            sections?: TOCItem[];

                                                                                                                                                                                              property selected

                                                                                                                                                                                              selected?: boolean;

                                                                                                                                                                                                property shouldOpenInNewTab

                                                                                                                                                                                                shouldOpenInNewTab?: boolean;

                                                                                                                                                                                                  Type Aliases

                                                                                                                                                                                                  type Example

                                                                                                                                                                                                  type Example = RuntimeCodeExample | MarkdownExample;

                                                                                                                                                                                                    type ExpandMode

                                                                                                                                                                                                    type ExpandMode = 'expand' | 'collapse' | 'hide';

                                                                                                                                                                                                      type ProcessedStyleguidistCSSConfig

                                                                                                                                                                                                      type ProcessedStyleguidistCSSConfig = Pick<ProcessedStyleguidistConfig, 'theme'> &
                                                                                                                                                                                                      Pick<ProcessedStyleguidistConfig, 'styles'>;


                                                                                                                                                                                                        namespace @vxna/mini-html-webpack-template

                                                                                                                                                                                                        module '@vxna/mini-html-webpack-template' {}

                                                                                                                                                                                                          function template

                                                                                                                                                                                                          template: (...args: any[]) => string;

                                                                                                                                                                                                            namespace acorn-jsx

                                                                                                                                                                                                            module 'acorn-jsx' {}

                                                                                                                                                                                                              function acornJsx

                                                                                                                                                                                                              acornJsx: () => (BaseParser: any) => any;

                                                                                                                                                                                                                namespace common-dir

                                                                                                                                                                                                                module 'common-dir' {}

                                                                                                                                                                                                                  function commonDir

                                                                                                                                                                                                                  commonDir: (list: string[]) => string;

                                                                                                                                                                                                                    namespace deabsdeep

                                                                                                                                                                                                                    module 'deabsdeep' {}

                                                                                                                                                                                                                      function deabsdeep

                                                                                                                                                                                                                      deabsdeep: <T>(objectToFreze: T, opt?: Options) => T;

                                                                                                                                                                                                                        namespace deepfreeze

                                                                                                                                                                                                                        module 'deepfreeze' {}

                                                                                                                                                                                                                          function deepfreeze

                                                                                                                                                                                                                          deepfreeze: <T>(objectToFreze: T) => T;

                                                                                                                                                                                                                            namespace findup

                                                                                                                                                                                                                            module 'findup' {}

                                                                                                                                                                                                                              variable findup

                                                                                                                                                                                                                              const findup: { sync(cwd: string, path: string): string };

                                                                                                                                                                                                                                namespace github-slugger

                                                                                                                                                                                                                                module 'github-slugger' {}

                                                                                                                                                                                                                                  class Slugger

                                                                                                                                                                                                                                  class Slugger {}

                                                                                                                                                                                                                                    method reset

                                                                                                                                                                                                                                    reset: () => void;

                                                                                                                                                                                                                                      method slug

                                                                                                                                                                                                                                      slug: (input: string) => string;

                                                                                                                                                                                                                                        namespace glogg

                                                                                                                                                                                                                                        module 'glogg' {}

                                                                                                                                                                                                                                          function getLogger

                                                                                                                                                                                                                                          getLogger: (namespace: string) => GloggLogger;

                                                                                                                                                                                                                                            namespace listify

                                                                                                                                                                                                                                            module 'listify' {}

                                                                                                                                                                                                                                              function listify

                                                                                                                                                                                                                                              listify: (list: any[], opt?: ListifyOptions) => string;

                                                                                                                                                                                                                                                namespace q-i

                                                                                                                                                                                                                                                module 'q-i' {}

                                                                                                                                                                                                                                                  function stringify

                                                                                                                                                                                                                                                  stringify: (obj: any) => string;

                                                                                                                                                                                                                                                    namespace react-docgen

                                                                                                                                                                                                                                                    module 'react-docgen' {}

                                                                                                                                                                                                                                                      variable defaultHandlers

                                                                                                                                                                                                                                                      const defaultHandlers: Handler[];

                                                                                                                                                                                                                                                        variable resolver

                                                                                                                                                                                                                                                        const resolver: {
                                                                                                                                                                                                                                                        findAllComponentDefinitions(ast: ASTNode): NodePath[];
                                                                                                                                                                                                                                                        ast: ASTNode,
                                                                                                                                                                                                                                                        recast: {
                                                                                                                                                                                                                                                        visit: (
                                                                                                                                                                                                                                                        path: NodePath,
                                                                                                                                                                                                                                                        handlers: { [handlerName: string]: () => boolean | undefined }
                                                                                                                                                                                                                                                        ) => void;
                                                                                                                                                                                                                                                        ): NodePath[];
                                                                                                                                                                                                                                                        findExportedComponentDefinition(ast: ASTNode): NodePath | undefined;

                                                                                                                                                                                                                                                          variable utils

                                                                                                                                                                                                                                                          const utils: { docblock: { getDoclets: (str?: string) => Record<string, any> } };

                                                                                                                                                                                                                                                            function parse

                                                                                                                                                                                                                                                            parse: (
                                                                                                                                                                                                                                                            source: string | Buffer,
                                                                                                                                                                                                                                                            resolver?: (
                                                                                                                                                                                                                                                            ast: ASTNode,
                                                                                                                                                                                                                                                            parser: { parse: (code: string) => ASTNode }
                                                                                                                                                                                                                                                            ) => NodePath<any, any> | NodePath[],
                                                                                                                                                                                                                                                            handlers?: Handler[],
                                                                                                                                                                                                                                                            options?: Options
                                                                                                                                                                                                                                                            ) => DocumentationObject | DocumentationObject[];
                                                                                                                                                                                                                                                            • Parse the components at filePath and return props, public methods, events and slots

                                                                                                                                                                                                                                                              Parameter filePath

                                                                                                                                                                                                                                                              absolute path of the parsed file

                                                                                                                                                                                                                                                              Parameter opts

                                                                                                                                                                                                                                                            interface Documentation

                                                                                                                                                                                                                                                            interface Documentation {}

                                                                                                                                                                                                                                                              method addComposes

                                                                                                                                                                                                                                                              addComposes: (moduleName: string) => void;

                                                                                                                                                                                                                                                                method get

                                                                                                                                                                                                                                                                get: (key: string) => any;

                                                                                                                                                                                                                                                                  method getChildContextDescriptor

                                                                                                                                                                                                                                                                  getChildContextDescriptor: (propName: string) => PropDescriptor;

                                                                                                                                                                                                                                                                    method getContextDescriptor

                                                                                                                                                                                                                                                                    getContextDescriptor: (propName: string) => PropDescriptor;

                                                                                                                                                                                                                                                                      method getPropDescriptor

                                                                                                                                                                                                                                                                      getPropDescriptor: (propName: string) => PropDescriptor;

                                                                                                                                                                                                                                                                        method set

                                                                                                                                                                                                                                                                        set: (key: string, value: any) => void;

                                                                                                                                                                                                                                                                          method toObject

                                                                                                                                                                                                                                                                          toObject: () => DocumentationObject;

                                                                                                                                                                                                                                                                            interface DocumentationObject

                                                                                                                                                                                                                                                                            interface DocumentationObject {}

                                                                                                                                                                                                                                                                              property childContext

                                                                                                                                                                                                                                                                              childContext?: {
                                                                                                                                                                                                                                                                              [chilCOntextName: string]: PropDescriptor;

                                                                                                                                                                                                                                                                                property composes

                                                                                                                                                                                                                                                                                composes?: string[];

                                                                                                                                                                                                                                                                                  property context

                                                                                                                                                                                                                                                                                  context?: {
                                                                                                                                                                                                                                                                                  [constextName: string]: PropDescriptor;

                                                                                                                                                                                                                                                                                    property description

                                                                                                                                                                                                                                                                                    description?: string;

                                                                                                                                                                                                                                                                                      property displayName

                                                                                                                                                                                                                                                                                      displayName?: string;

                                                                                                                                                                                                                                                                                        property methods

                                                                                                                                                                                                                                                                                        methods?: MethodDescriptor[];

                                                                                                                                                                                                                                                                                          property props

                                                                                                                                                                                                                                                                                          props?: {
                                                                                                                                                                                                                                                                                          [propName: string]: PropDescriptor;

                                                                                                                                                                                                                                                                                            property tags

                                                                                                                                                                                                                                                                                            tags?: TagProps;

                                                                                                                                                                                                                                                                                              interface MethodDescriptor

                                                                                                                                                                                                                                                                                              interface MethodDescriptor {}

                                                                                                                                                                                                                                                                                                property description

                                                                                                                                                                                                                                                                                                description?: string;

                                                                                                                                                                                                                                                                                                  property docblock

                                                                                                                                                                                                                                                                                                  docblock?: string;

                                                                                                                                                                                                                                                                                                    property modifiers

                                                                                                                                                                                                                                                                                                    modifiers?: string[];

                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                                        property params

                                                                                                                                                                                                                                                                                                        params?: any[];

                                                                                                                                                                                                                                                                                                          property returns

                                                                                                                                                                                                                                                                                                          returns?: {
                                                                                                                                                                                                                                                                                                          name: string;
                                                                                                                                                                                                                                                                                                          [key: string]: any;
                                                                                                                                                                                                                                                                                                          } | null;

                                                                                                                                                                                                                                                                                                            property tags

                                                                                                                                                                                                                                                                                                            tags?: TagProps;

                                                                                                                                                                                                                                                                                                              interface Options

                                                                                                                                                                                                                                                                                                              interface Options {}

                                                                                                                                                                                                                                                                                                                property babelrc

                                                                                                                                                                                                                                                                                                                babelrc?: string;

                                                                                                                                                                                                                                                                                                                  property babelrcRoots

                                                                                                                                                                                                                                                                                                                  babelrcRoots?: boolean | string | string[];

                                                                                                                                                                                                                                                                                                                    property configFile

                                                                                                                                                                                                                                                                                                                    configFile?: string;

                                                                                                                                                                                                                                                                                                                      property cwd

                                                                                                                                                                                                                                                                                                                      cwd?: string;

                                                                                                                                                                                                                                                                                                                        property envName

                                                                                                                                                                                                                                                                                                                        envName?: string;

                                                                                                                                                                                                                                                                                                                          property filename

                                                                                                                                                                                                                                                                                                                          filename?: string;

                                                                                                                                                                                                                                                                                                                            property root

                                                                                                                                                                                                                                                                                                                            root?: string;

                                                                                                                                                                                                                                                                                                                              property rootMode

                                                                                                                                                                                                                                                                                                                              rootMode?: 'root' | 'upward' | 'upward-optional';

                                                                                                                                                                                                                                                                                                                                interface PropDescriptor

                                                                                                                                                                                                                                                                                                                                interface PropDescriptor {}

                                                                                                                                                                                                                                                                                                                                  property defaultValue

                                                                                                                                                                                                                                                                                                                                  defaultValue?: any;

                                                                                                                                                                                                                                                                                                                                    property description

                                                                                                                                                                                                                                                                                                                                    description?: string;

                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                                                                        property required

                                                                                                                                                                                                                                                                                                                                        required?: boolean;

                                                                                                                                                                                                                                                                                                                                          property tags

                                                                                                                                                                                                                                                                                                                                          tags?: TagProps;

                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                            type?: PropTypeDescriptor;

                                                                                                                                                                                                                                                                                                                                              interface PropTypeDescriptor

                                                                                                                                                                                                                                                                                                                                              interface PropTypeDescriptor {}

                                                                                                                                                                                                                                                                                                                                                property computed

                                                                                                                                                                                                                                                                                                                                                computed?: boolean;

                                                                                                                                                                                                                                                                                                                                                  property description

                                                                                                                                                                                                                                                                                                                                                  description?: string;

                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                    | 'arrayOf'
                                                                                                                                                                                                                                                                                                                                                    | 'custom'
                                                                                                                                                                                                                                                                                                                                                    | 'enum'
                                                                                                                                                                                                                                                                                                                                                    | 'array'
                                                                                                                                                                                                                                                                                                                                                    | 'bool'
                                                                                                                                                                                                                                                                                                                                                    | 'func'
                                                                                                                                                                                                                                                                                                                                                    | 'number'
                                                                                                                                                                                                                                                                                                                                                    | 'object'
                                                                                                                                                                                                                                                                                                                                                    | 'string'
                                                                                                                                                                                                                                                                                                                                                    | 'any'
                                                                                                                                                                                                                                                                                                                                                    | 'element'
                                                                                                                                                                                                                                                                                                                                                    | 'node'
                                                                                                                                                                                                                                                                                                                                                    | 'symbol'
                                                                                                                                                                                                                                                                                                                                                    | 'objectOf'
                                                                                                                                                                                                                                                                                                                                                    | 'shape'
                                                                                                                                                                                                                                                                                                                                                    | 'exact'
                                                                                                                                                                                                                                                                                                                                                    | 'instanceOf'
                                                                                                                                                                                                                                                                                                                                                    | 'elementType';

                                                                                                                                                                                                                                                                                                                                                      property raw

                                                                                                                                                                                                                                                                                                                                                      raw?: string;

                                                                                                                                                                                                                                                                                                                                                        property required

                                                                                                                                                                                                                                                                                                                                                        required?: boolean;

                                                                                                                                                                                                                                                                                                                                                          property value

                                                                                                                                                                                                                                                                                                                                                          value?: any;

                                                                                                                                                                                                                                                                                                                                                            interface TagObject

                                                                                                                                                                                                                                                                                                                                                            interface TagObject extends Omit<Tag, 'description'> {}

                                                                                                                                                                                                                                                                                                                                                              property description

                                                                                                                                                                                                                                                                                                                                                              description?: string;

                                                                                                                                                                                                                                                                                                                                                                interface TagParamObject

                                                                                                                                                                                                                                                                                                                                                                interface TagParamObject extends TagObject {}

                                                                                                                                                                                                                                                                                                                                                                  property default

                                                                                                                                                                                                                                                                                                                                                                  default?: string;

                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                      type?: Type | null;

                                                                                                                                                                                                                                                                                                                                                                        interface TagProps

                                                                                                                                                                                                                                                                                                                                                                        interface TagProps {}

                                                                                                                                                                                                                                                                                                                                                                          property arg

                                                                                                                                                                                                                                                                                                                                                                          arg?: TagParamObject[];

                                                                                                                                                                                                                                                                                                                                                                            property argument

                                                                                                                                                                                                                                                                                                                                                                            argument?: TagParamObject[];

                                                                                                                                                                                                                                                                                                                                                                              property author

                                                                                                                                                                                                                                                                                                                                                                              author?: TagObject[];

                                                                                                                                                                                                                                                                                                                                                                                property deprecated

                                                                                                                                                                                                                                                                                                                                                                                deprecated?: TagObject[];
                                                                                                                                                                                                                                                                                                                                                                                  link?: TagObject[];

                                                                                                                                                                                                                                                                                                                                                                                    property param

                                                                                                                                                                                                                                                                                                                                                                                    param?: TagParamObject[];

                                                                                                                                                                                                                                                                                                                                                                                      property return

                                                                                                                                                                                                                                                                                                                                                                                      return?: TagParamObject[];

                                                                                                                                                                                                                                                                                                                                                                                        property returns

                                                                                                                                                                                                                                                                                                                                                                                        returns?: TagParamObject[];

                                                                                                                                                                                                                                                                                                                                                                                          property see

                                                                                                                                                                                                                                                                                                                                                                                          see?: TagObject[];

                                                                                                                                                                                                                                                                                                                                                                                            property since

                                                                                                                                                                                                                                                                                                                                                                                            since?: TagObject[];

                                                                                                                                                                                                                                                                                                                                                                                              property version

                                                                                                                                                                                                                                                                                                                                                                                              version?: TagObject[];

                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                [title: string]: TagObject[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                  type Handler

                                                                                                                                                                                                                                                                                                                                                                                                  type Handler = (documentation: Documentation, path: NodePath) => void;

                                                                                                                                                                                                                                                                                                                                                                                                    namespace react-docgen-annotation-resolver

                                                                                                                                                                                                                                                                                                                                                                                                    module 'react-docgen-annotation-resolver' {}

                                                                                                                                                                                                                                                                                                                                                                                                      function annotationResolver

                                                                                                                                                                                                                                                                                                                                                                                                      annotationResolver: (
                                                                                                                                                                                                                                                                                                                                                                                                      ast: AnnoASTNode,
                                                                                                                                                                                                                                                                                                                                                                                                      recast: {
                                                                                                                                                                                                                                                                                                                                                                                                      visit: (
                                                                                                                                                                                                                                                                                                                                                                                                      node: AnnoNodePath,
                                                                                                                                                                                                                                                                                                                                                                                                      handlers: { [handlerName: string]: () => boolean | undefined }
                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                      ) => AnnoNodePath[];

                                                                                                                                                                                                                                                                                                                                                                                                        namespace react-docgen-displayname-handler

                                                                                                                                                                                                                                                                                                                                                                                                        module 'react-docgen-displayname-handler' {}

                                                                                                                                                                                                                                                                                                                                                                                                          function createDisplayNameHandler

                                                                                                                                                                                                                                                                                                                                                                                                          createDisplayNameHandler: (componentPath: string) => Handler;

                                                                                                                                                                                                                                                                                                                                                                                                            type Handler

                                                                                                                                                                                                                                                                                                                                                                                                            type Handler = (
                                                                                                                                                                                                                                                                                                                                                                                                            documentation: Documentation,
                                                                                                                                                                                                                                                                                                                                                                                                            path: DisplaNameHandlerNodePath
                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                              namespace strip-html-comments

                                                                                                                                                                                                                                                                                                                                                                                                              module 'strip-html-comments' {}

                                                                                                                                                                                                                                                                                                                                                                                                                function stripHtmlComments

                                                                                                                                                                                                                                                                                                                                                                                                                stripHtmlComments: (text: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                  namespace strip-shebang

                                                                                                                                                                                                                                                                                                                                                                                                                  module 'strip-shebang' {}

                                                                                                                                                                                                                                                                                                                                                                                                                    function stripShebang

                                                                                                                                                                                                                                                                                                                                                                                                                    stripShebang: (input: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                      namespace to-ast

                                                                                                                                                                                                                                                                                                                                                                                                                      module 'to-ast' {}

                                                                                                                                                                                                                                                                                                                                                                                                                        function toAST

                                                                                                                                                                                                                                                                                                                                                                                                                        toAST: (obj: any) => ASTNode;

                                                                                                                                                                                                                                                                                                                                                                                                                          namespace webpack-merge

                                                                                                                                                                                                                                                                                                                                                                                                                          module 'webpack-merge' {}

                                                                                                                                                                                                                                                                                                                                                                                                                            variable webpackMerge

                                                                                                                                                                                                                                                                                                                                                                                                                            const webpackMerge: {
                                                                                                                                                                                                                                                                                                                                                                                                                            (options: WebpackMergeOptions): mergeFunction;
                                                                                                                                                                                                                                                                                                                                                                                                                            (...configs: MetaConfig[]): Configuration;
                                                                                                                                                                                                                                                                                                                                                                                                                            key: string,
                                                                                                                                                                                                                                                                                                                                                                                                                            uniques: string[],
                                                                                                                                                                                                                                                                                                                                                                                                                            getter?: (plugin: Tapable.Plugin) => string | undefined | false
                                                                                                                                                                                                                                                                                                                                                                                                                            ): customizeArrayFuntion;

                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (23)

                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (62)

                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (71)

                                                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (2)


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

                                                                                                                                                                                                                                                                                                                                                                                                                              You may also use to create a custom badge linking to

                                                                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                <a href=""><img src="" alt=""></a>