@procore/core-react/typedoc.js

const TypeDoc = require('typedoc')
const fs = require('fs-extra')

async function main() {
  const app = new TypeDoc.Application()

  app.options.addReader(new TypeDoc.TSConfigReader())
  app.options.addReader(new TypeDoc.TypeDocReader())

  app.bootstrap({
    tsconfig: 'tsconfig.dev.json',
    excludeExternals: true,
    entryPoints: ['./src/utils/propsTypedoc.ts'],
  })

  const project = app.convert()

  if (project) {
    const outputDir = 'dist/props'

    fs.ensureDirSync(outputDir)

    await app.generateJson(project, outputDir + '/allProps.json')

    let allProps = JSON.parse(
      fs.readFileSync(outputDir + '/allProps.json', 'utf-8')
    )

    // Group the interfaces by which component they're associated with
    const componentPropsInterfaces = allProps.children.reduce(
      (acc, interface) => {
        const componentName =
          interface && interface.sources[0].fileName
            ? interface.sources[0].fileName.split('/').reverse()[1]
            : null

        if (acc[componentName]) {
          acc[componentName].push(interface)
        } else {
          acc[componentName] = [interface]
        }

        return acc
      },
      {}
    )

    // Clean up the interfaces such that only the important information remains
    Object.entries(componentPropsInterfaces).forEach(
      ([componentName, interfaces]) => {
        componentProps = interfaces.reduce((acc, interface) => {
          if (interface.children) {
            const formattedPropsObject = interface.children.reduce(
              (acc, prop) => {
                const { name, type } = prop
                const formattedType = formatType(type, interfaces)
                const required = !prop.flags.isOptional
                const description = prop.comment ? prop.comment.shortText : null
                const defaultValueTag =
                  prop.comment && prop.comment.tags
                    ? prop.comment.tags.find(
                        (tag) => tag.tag === 'defaultvalue'
                      )
                    : null
                const defaultValue = defaultValueTag
                  ? defaultValueTag.text
                  : null

                const fields = {
                  name,
                  type: formattedType,
                  required,
                  description,
                  defaultValue,
                }

                acc.push(fields)
                return acc
              },
              []
            )

            acc[interface.name] = formattedPropsObject
          }
          return acc
        }, {})

        fs.writeFileSync(
          `${outputDir}/${componentName}.json`,
          JSON.stringify(componentProps)
        )
      }
    )
  }
}

function formatType(type, interfaces) {
  if (type.type === 'union') {
    // Join the union of types into a string
    return type.types
      .reduce((acc, curr) => {
        if (curr.name !== 'undefined') {
          curr.name ? acc.push(curr.name) : acc.push(curr.value)
        }
        return acc
      }, [])
      .join(' | ')
  } else if (type.type === 'reference' && type.id) {
    // Resolve the reference
    referencedInterface = interfaces.find(
      (interface) => type.id === interface.id
    )

    return formatType(referencedInterface.type, interfaces)
  } else {
    return type.name
  }
}

main().catch(console.error)