Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 

uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 

uid=33(www-data) gid=33(www-data) groups=33(www-data) 

Safe-mode: OFF (not secure)

/var/www/html/pmb/node_modules/fork-ts-checker-webpack-plugin/lib/eslint-reporter/reporter/   drwxr-xr-x
Free 13.25 GB of 57.97 GB (22.86%)
                            Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Self remove    Logout    

Viewing file:     EsLintReporter.js (8.7 KB)      -rw-r--r--

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    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) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const EsLintIssueFactory_1 = require("../issue/EsLintIssueFactory");
const path_1 = __importDefault(require("path"));
const fs_extra_1 = __importDefault(require("fs-extra"));
const minimatch_1 = __importDefault(require("minimatch"));
const glob_1 = __importDefault(require("glob"));
const isOldCLIEngine = (eslint) => eslint.resolveFileGlobPatterns !== undefined;
function createEsLintReporter(configuration) {
    // eslint-disable-next-line @typescript-eslint/no-var-requires
    const { CLIEngine, ESLint } = require('eslint');
    const eslint = ESLint
        ? new ESLint(configuration.options)
        : new CLIEngine(configuration.options);
    let isInitialRun = true;
    let isInitialGetFiles = true;
    const lintResults = new Map();
    const includedGlobPatterns = resolveFileGlobPatterns(configuration.files);
    const includedFiles = new Set();
    function isFileIncluded(path) {
        return __awaiter(this, void 0, void 0, function* () {
            return (!path.includes('node_modules') &&
                includedGlobPatterns.some((pattern) => minimatch_1.default(path, pattern)) &&
                !(yield eslint.isPathIgnored(path)));
        });
    }
    function getFiles() {
        return __awaiter(this, void 0, void 0, function* () {
            if (isInitialGetFiles) {
                isInitialGetFiles = false;
                const resolvedGlobs = yield Promise.all(includedGlobPatterns.map((globPattern) => new Promise((resolve) => {
                    glob_1.default(globPattern, (error, resolvedFiles) => {
                        if (error) {
                            // fail silently
                            resolve([]);
                        }
                        else {
                            resolve(resolvedFiles || []);
                        }
                    });
                })));
                for (const resolvedGlob of resolvedGlobs) {
                    for (const resolvedFile of resolvedGlob) {
                        if (yield isFileIncluded(resolvedFile)) {
                            includedFiles.add(resolvedFile);
                        }
                    }
                }
            }
            return Array.from(includedFiles);
        });
    }
    function getDirs() {
        return includedGlobPatterns || [];
    }
    function getExtensions() {
        return configuration.options.extensions || [];
    }
    // Copied from the eslint 6 implementation, as it's not available in eslint 8
    function resolveFileGlobPatterns(globPatterns) {
        if (configuration.options.globInputPaths === false) {
            return globPatterns.filter(Boolean);
        }
        const extensions = getExtensions().map((ext) => ext.replace(/^\./u, ''));
        const dirSuffix = `/**/*.{${extensions.join(',')}}`;
        return globPatterns.filter(Boolean).map((globPattern) => {
            const resolvedPath = path_1.default.resolve(configuration.options.cwd || '', globPattern);
            const newPath = directoryExists(resolvedPath)
                ? globPattern.replace(/[/\\]$/u, '') + dirSuffix
                : globPattern;
            return path_1.default.normalize(newPath).replace(/\\/gu, '/');
        });
    }
    // Copied from the eslint 6 implementation, as it's not available in eslint 8
    function directoryExists(resolvedPath) {
        try {
            return fs_extra_1.default.statSync(resolvedPath).isDirectory();
        }
        catch (error) {
            if (error && error.code === 'ENOENT') {
                return false;
            }
            throw error;
        }
    }
    return {
        getReport: ({ changedFiles = [], deletedFiles = [] }) => __awaiter(this, void 0, void 0, function* () {
            return {
                getDependencies() {
                    return __awaiter(this, void 0, void 0, function* () {
                        for (const changedFile of changedFiles) {
                            if (yield isFileIncluded(changedFile)) {
                                includedFiles.add(changedFile);
                            }
                        }
                        for (const deletedFile of deletedFiles) {
                            includedFiles.delete(deletedFile);
                        }
                        return {
                            files: (yield getFiles()).map((file) => path_1.default.normalize(file)),
                            dirs: getDirs().map((dir) => path_1.default.normalize(dir)),
                            excluded: [],
                            extensions: getExtensions(),
                        };
                    });
                },
                getIssues() {
                    return __awaiter(this, void 0, void 0, function* () {
                        // cleanup old results
                        for (const changedFile of changedFiles) {
                            lintResults.delete(changedFile);
                        }
                        for (const deletedFile of deletedFiles) {
                            lintResults.delete(deletedFile);
                        }
                        // get reports
                        const lintReports = [];
                        if (isInitialRun) {
                            const lintReport = yield (isOldCLIEngine(eslint)
                                ? Promise.resolve(eslint.executeOnFiles(includedGlobPatterns))
                                : eslint.lintFiles(includedGlobPatterns).then((results) => ({ results })));
                            lintReports.push(lintReport);
                            isInitialRun = false;
                        }
                        else {
                            // we need to take care to not lint files that are not included by the configuration.
                            // the eslint engine will not exclude them automatically
                            const changedAndIncludedFiles = [];
                            for (const changedFile of changedFiles) {
                                if (yield isFileIncluded(changedFile)) {
                                    changedAndIncludedFiles.push(changedFile);
                                }
                            }
                            if (changedAndIncludedFiles.length) {
                                const lintReport = yield (isOldCLIEngine(eslint)
                                    ? Promise.resolve(eslint.executeOnFiles(changedAndIncludedFiles))
                                    : eslint.lintFiles(changedAndIncludedFiles).then((results) => ({ results })));
                                lintReports.push(lintReport);
                            }
                        }
                        // output fixes if `fix` option is provided
                        if (configuration.options.fix) {
                            yield Promise.all(lintReports.map((lintReport) => isOldCLIEngine(eslint)
                                ? CLIEngine.outputFixes(lintReport)
                                : ESLint.outputFixes(lintReport.results)));
                        }
                        // store results
                        for (const lintReport of lintReports) {
                            for (const lintResult of lintReport.results) {
                                lintResults.set(lintResult.filePath, lintResult);
                            }
                        }
                        // get actual list of previous and current reports
                        const results = Array.from(lintResults.values());
                        return EsLintIssueFactory_1.createIssuesFromEsLintResults(results);
                    });
                },
                close() {
                    return __awaiter(this, void 0, void 0, function* () {
                        // do nothing
                    });
                },
            };
        }),
    };
}
exports.createEsLintReporter = createEsLintReporter;