@nx/eslint/src/utils/rules-requiring-type-checking.js

The ESLint plugin for Nx contains executors, generators and utilities used for linting JavaScript/TypeScript projects within an Nx workspace.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.hasRulesRequiringTypeChecking = hasRulesRequiringTypeChecking;
exports.removeParserOptionsProjectIfNotRequired = removeParserOptionsProjectIfNotRequired;
// Cache the resolved rules from node_modules
let knownRulesRequiringTypeChecking = null;
function resolveKnownRulesRequiringTypeChecking() {
    if (knownRulesRequiringTypeChecking) {
        return knownRulesRequiringTypeChecking;
    }
    try {
        const { rules } = require('@typescript-eslint/eslint-plugin');
        const rulesRequiringTypeInfo = Object.entries(rules)
            .map(([ruleName, config]) => {
            if (config.meta?.docs?.requiresTypeChecking) {
                return `@typescript-eslint/${ruleName}`;
            }
            return null;
        })
            .filter(Boolean);
        return rulesRequiringTypeInfo;
    }
    catch (err) {
        console.log(err);
        return null;
    }
}
function hasRulesRequiringTypeChecking(eslintConfig) {
    knownRulesRequiringTypeChecking = resolveKnownRulesRequiringTypeChecking();
    if (!knownRulesRequiringTypeChecking) {
        /**
         * If (unexpectedly) known rules requiring type checking could not be resolved,
         * default to assuming that the rules are in use to align most closely with Nx
         * ESLint configs to date.
         */
        return true;
    }
    const allRulesInConfig = getAllRulesInConfig(eslintConfig);
    return allRulesInConfig.some((rule) => knownRulesRequiringTypeChecking.includes(rule));
}
function removeParserOptionsProjectIfNotRequired(json) {
    // At least one rule requiring type-checking is in use, do not migrate the config
    if (hasRulesRequiringTypeChecking(json)) {
        return json;
    }
    removeProjectParserOptionFromConfig(json);
    return json;
}
function determineEnabledRules(rules) {
    return Object.entries(rules)
        .filter(([key, value]) => {
        return !(typeof value === 'string' && value === 'off');
    })
        .map(([ruleName]) => ruleName);
}
function getAllRulesInConfig(json) {
    let allRules = json.rules ? determineEnabledRules(json.rules) : [];
    if (json.overrides?.length > 0) {
        for (const o of json.overrides) {
            if (o.rules) {
                allRules = allRules = [...allRules, ...determineEnabledRules(o.rules)];
            }
        }
    }
    return allRules;
}
function removeProjectParserOptionFromConfig(json) {
    delete json.parserOptions?.project;
    // If parserOptions is left empty by this removal, also clean up the whole object
    if (json.parserOptions && Object.keys(json.parserOptions).length === 0) {
        delete json.parserOptions;
    }
    if (json.overrides) {
        for (const override of json.overrides) {
            delete override.parserOptions?.project;
            // If parserOptions is left empty by this removal, also clean up the whole object
            if (override.parserOptions &&
                Object.keys(override.parserOptions).length === 0) {
                delete override.parserOptions;
            }
        }
    }
}