typescript-assistant/dist/code-style/linter.js

Combines and integrates professional Typescript tools into your project

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const util_1 = require("../util");
const child_process_1 = require("child_process");
exports.createLinter = (dependencies) => {
    let { logger, bus, git } = dependencies;
    let logError = (err) => logger.error('linter', `error: ${err}`);
    let lintProcess;
    let running = false;
    let rescheduled = false;
    let fix = false;
    let errors = 0;
    let fixable = 0;
    let startLint = (files) => __awaiter(this, void 0, void 0, function* () {
        rescheduled = false;
        running = true;
        bus.report({
            tool: 'lint',
            status: 'busy'
        });
        if (!files) {
            files = (yield git.findChangedFiles()).filter(util_1.isTypescriptFile);
        }
        logger.log('linter', `Linting ${files.length} files...`);
        errors = 0;
        fixable = 0;
        let command = {
            fix: fix,
            filesToLint: files
        };
        lintProcess.send(command);
    });
    let lint = (files) => {
        if (rescheduled) {
            return;
        }
        else if (running) {
            rescheduled = true;
        }
        else {
            startLint(files).catch(logError);
        }
    };
    let startProcess = () => {
        lintProcess = child_process_1.fork(`${__dirname}/linter-process`, [], {
            execArgv: process.execArgv.filter(arg => !arg.includes('inspect'))
        });
        lintProcess.on('close', (code) => {
            if (code !== 0 && code !== null) {
                logger.log('linter', `linting process exited with code ${code}`);
            }
        });
        lintProcess.on('message', (response) => {
            if (response.violation) {
                let { fileName, line, column, message, hasFix } = response.violation;
                errors++;
                if (hasFix) {
                    fixable++;
                }
                logger.log('linter', `${util_1.absolutePath(fileName)}:${line}:${column} ${message}`);
            }
            if (response.finished) {
                running = false;
                logger.log('linter', response.finished.success
                    ? 'All files are ok'
                    : `${errors} Linting problems found, ${fixable} ${fix ? 'fixed' : 'fixable'}`);
                bus.signal(response.finished.success ? 'lint-linted' : 'lint-errored');
                bus.report({
                    tool: 'lint',
                    status: 'ready',
                    errors: errors,
                    fixable: fixable
                });
                if (rescheduled) {
                    startLint().catch(logError);
                }
            }
            if (response.error) {
                logger.error('linter', response.error.message);
            }
        });
    };
    let lintCallback = () => lint();
    return {
        start: (trigger) => {
            startProcess();
            bus.register(trigger, lintCallback);
        },
        stop: () => {
            bus.unregister(lintCallback);
            lintProcess.kill();
            lintProcess = undefined;
        },
        lintOnce: (fixOnce, files) => {
            fix = fixOnce;
            let isRunning = lintProcess !== undefined;
            if (!isRunning) {
                startProcess();
            }
            return new Promise((resolve) => {
                let ready = () => {
                    bus.unregister(linted);
                    bus.unregister(errored);
                    fix = false;
                    if (!isRunning) {
                        lintProcess.kill();
                        lintProcess = undefined;
                    }
                };
                let linted = () => {
                    ready();
                    resolve(true);
                };
                let errored = () => {
                    ready();
                    resolve(false);
                };
                bus.register('lint-linted', linted);
                bus.register('lint-errored', errored);
                lint(files);
            });
        }
    };
};
//# sourceMappingURL=linter.js.map