• Version 2.4.0
  • Published
  • 93.3 kB
  • 18 dependencies
  • MIT license


npm i docz
yarn add docz
pnpm add docz


It's has never been so easy to documents your things!



variable ComponentsProvider

const ComponentsProvider: FC<ComponentsProviderProps>;

    variable doczState

    const doczState: State<DoczState>;

      variable Playground

      const Playground: FC<PlaygroundProps>;

        variable Props

        const Props: FC<PropsProps>;


          function theme

          theme: (
          themeConfig: ThemeConfig,
          transform?: TransformFn
          ) => (WrappedComponent: CT) => CT<ThemeProps>;

            function useComponentProps

            useComponentProps: ({ componentName, fileName }: UseComponentPropsParams) => any;

              function useComponents

              useComponents: () => ComponentsMap;

                function useConfig

                useConfig: () => UseConfigObj;

                  function useCurrentDoc

                  useCurrentDoc: () => any;

                    function useDataServer

                    useDataServer: (url: string | undefined) => void;

                      function useDocs

                      useDocs: () => Entry[] | null;

                        function useMenus

                        useMenus: (opts?: UseMenusParams | undefined) => MenuItem[] | null;

                          function usePrevious

                          usePrevious: (value: any, defaultValue?: any) => any;

                            function useWindowSize

                            useWindowSize: (
                            throttleMs?: number,
                            _initialWidth?: number,
                            initialHeight?: number
                            ) => {
                            innerHeight: number;
                            innerWidth: number;
                            outerHeight: number;
                            outerWidth: number;


                              interface ComponentsMap

                              interface ComponentsMap {}

                                property layout

                                layout?: CT<LayoutProps>;

                                  property notFound

                                  notFound?: CT;

                                    property playground

                                    playground?: CT<PlaygroundProps>;

                                      index signature

                                      [key: string]: any;

                                        interface ComponentsProviderProps

                                        interface ComponentsProviderProps {}

                                          property components

                                          components: ComponentsMap;

                                            interface Entry

                                            interface Entry {}

                                              property filepath

                                              filepath: string;

                                                property headings

                                                headings: Heading[];

                                                  property id

                                                  id: string;

                                                    property menu

                                                    menu: string | null;

                                                      property name

                                                      name: string;

                                                        property order

                                                        order: number;

                                                          property route

                                                          route: string;

                                                            property slug

                                                            slug: string;

                                                              index signature

                                                              [key: string]: any;

                                                                interface LayoutProps

                                                                interface LayoutProps {}

                                                                  property doc

                                                                  doc: Entry;

                                                                    index signature

                                                                    [key: string]: any;
                                                                      interface MenuItem {}
                                                                        href?: string;
                                                                          id: string;
                                                                            menu?: MenuItem[];
                                                                              name: string;
                                                                                order?: number;
                                                                                  parent?: string;
                                                                                    route?: string;
                                                                                      [key: string]: any;

                                                                                        interface PlaygroundProps

                                                                                        interface PlaygroundProps {}

                                                                                          property children

                                                                                          children: any;

                                                                                            property className

                                                                                            className?: string;

                                                                                              property language

                                                                                              language?: string;

                                                                                                property style

                                                                                                style?: any;

                                                                                                  property useScoping

                                                                                                  useScoping?: boolean;

                                                                                                    property wrapper

                                                                                                    wrapper?: ComponentType<any>;

                                                                                                      interface PropsComponentProps

                                                                                                      interface PropsComponentProps {}

                                                                                                        property isRaw

                                                                                                        isRaw?: boolean;

                                                                                                          property isToggle

                                                                                                          isToggle?: boolean;

                                                                                                            property of

                                                                                                            of: ComponentWithDocGenInfo;

                                                                                                              property props

                                                                                                              props: Record<string, Prop>;

                                                                                                                property title

                                                                                                                title?: Node;

                                                                                                                  method getPropType

                                                                                                                  getPropType: (prop: Prop) => string;

                                                                                                                    index signature

                                                                                                                    [key: string]: any;

                                                                                                                      interface UseConfigObj

                                                                                                                      interface UseConfigObj extends Config {}

                                                                                                                        property themeConfig

                                                                                                                        themeConfig: ThemeConfig;

                                                                                                                          Type Aliases

                                                                                                                          type ThemeConfig

                                                                                                                          type ThemeConfig = Record<string, any>;

                                                                                                                            Package Files (14)

                                                                                                                            Dependencies (18)

                                                                                                                            Dev Dependencies (0)

                                                                                                                            No dev dependencies.

                                                                                                                            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>