export async function lint()

in src/lint.ts [15:61]
39 lines of code
13 McCabe index (conditional complexity)

export async function lint(
    dirPath: string,
    minVersion: TsVersion,
    maxVersion: TsVersion,
    isLatest: boolean,
    expectOnly: boolean,
    tsLocal: string | undefined): Promise<string | undefined> {
    const tsconfigPath = joinPaths(dirPath, "tsconfig.json");
    const lintProgram = Linter.createProgram(tsconfigPath);

    for (const version of [maxVersion, minVersion]) {
        const errors = testDependencies(version, dirPath, lintProgram, tsLocal);
        if (errors) { return errors; }
    }

    const lintOptions: ILinterOptions = {
        fix: false,
        formatter: "stylish",
    };
    const linter = new Linter(lintOptions, lintProgram);
    const configPath = expectOnly ? joinPaths(__dirname, "..", "dtslint-expect-only.json") : getConfigPath(dirPath);
    const config = await getLintConfig(configPath, tsconfigPath, minVersion, maxVersion, tsLocal);

    for (const file of lintProgram.getSourceFiles()) {
        if (lintProgram.isSourceFileDefaultLibrary(file)) { continue; }

        const { fileName, text } = file;
        if (!fileName.includes("node_modules")) {
            const err = testNoTsIgnore(text) || testNoTslintDisables(text);
            if (err) {
                const { pos, message } = err;
                const place = file.getLineAndCharacterOfPosition(pos);
                return `At ${fileName}:${JSON.stringify(place)}: ${message}`;
            }
        }

        // External dependencies should have been handled by `testDependencies`;
        // typesVersions should be handled in a separate lint
        if (!isExternalDependency(file, dirPath, lintProgram) &&
            (!isLatest || !isTypesVersionPath(fileName, dirPath))) {
            linter.lint(fileName, text, config);
        }
    }

    const result = linter.getResult();
    return result.failures.length ? result.output : undefined;
}