Function createApiDtsFiles

packages/tooling/src/typescript.ts:165–241

(
    dtsBaseDir: string,
    dtsFiles: string[],
    projectDir: string,
    outDir: string,
    logger: Logger
)

}

export async function createApiDtsFiles(
    dtsBaseDir: string,
    dtsFiles: string[],
    projectDir: string,
    outDir: string,
    logger: Logger
) {
    const commandLine = ts.parseCommandLine([]);
    if (!commandLine.options.project) {
        commandLine.options.project = path.resolve(projectDir, 'tsconfig.json');
    }

    const reportDiagnostic = createDiagnosticReporter(true, logger);

    const parseConfigFileHost: ts.ParseConfigFileHost = ts.sys as any;
    parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = diagnostic => {
        reportDiagnostic(diagnostic);
        ts.sys.exit(ts.ExitStatus.InvalidProject_OutputsSkipped);
    };

    const parsedCommandLine = ts.getParsedCommandLineOfConfigFile(
        commandLine.options.project!,
        commandLine.options,
        parseConfigFileHost,
        /*extendedConfigCache*/ undefined,
        commandLine.watchOptions
    )!;

    const removedSymbols = new Set<string>();

    const program = ts.createProgram({
        rootNames: dtsFiles,
        options: parsedCommandLine.options,
        projectReferences: parsedCommandLine.projectReferences,
        host: ts.createCompilerHost(parsedCommandLine.options)
    });

    let sourceFiles = dtsFiles.map(f => program.getSourceFile(f)!);

    const checker = program.getTypeChecker();

    // Pass 1: Filter all exports
    sourceFiles = sourceFiles.map(
        s => ts.visitEachChild(s, filterDtsVisitor(checker, s, removedSymbols, logger.warn), undefined) as ts.SourceFile
    );

    // Pass 2: Filter imports of remoevd exports
    sourceFiles = sourceFiles.map(
        s => ts.visitEachChild(s, filterDtsImportsVisitor(checker, removedSymbols), undefined) as ts.SourceFile
    );

    // Pass 3: filter any files which do not have any exports
    sourceFiles = sourceFiles.filter(s =>
        s.statements.some(
            e =>
                ts.isExportDeclaration(e) ||
                (ts.canHaveModifiers(e) && e.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword))
        )