@nx/eslint 0.0.0-pr-22179-271588f

package/src/migrations/update-17-2-9/move-options-to-target-defaults.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const eslint_file_1 = require("../../generators/utils/eslint-file");
+const project_configuration_utils_1 = require("nx/src/project-graph/utils/project-configuration-utils");
+async function update(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    // Don't override anything if there are already target defaults for eslint
+    if (nxJson.targetDefaults?.['@nx/eslint:lint']) {
+        return;
+    }
+    nxJson.targetDefaults ??= {};
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    const lintTargets = new Set();
+    (0, executor_options_utils_1.forEachExecutorOptionsInGraph)(graph, '@nx/eslint:lint', (value, proj, targetName) => {
+        lintTargets.add(targetName);
+    });
+    // Workspace does not use eslint?
+    if (lintTargets.size === 0) {
+        return;
+    }
+    const lintDefaults = (nxJson.targetDefaults['@nx/eslint:lint'] = {});
+    // All eslint targets have the same name
+    if (lintTargets.size === 1) {
+        const targetName = Array.from(lintTargets)[0];
+        if (nxJson.targetDefaults[targetName]) {
+            Object.assign(lintDefaults, nxJson.targetDefaults[targetName]);
+        }
+    }
+    lintDefaults.cache ??= true;
+    if (!lintDefaults.inputs) {
+        const eslintConfig = (0, eslint_file_1.findEslintFile)(tree);
+        lintDefaults.inputs = [
+            'default',
+            ...(eslintConfig ? [`{workspaceRoot}/${eslintConfig}`] : []),
+            '{workspaceRoot}/tools/eslint-rules/**/*',
+        ];
+    }
+    // Cleanup old target defaults
+    const projects = graph.nodes;
+    const projectMap = (0, devkit_1.getProjects)(tree);
+    for (const [targetDefaultKey, targetDefault] of Object.entries(nxJson.targetDefaults)) {
+        if (!isTargetDefaultUsed(targetDefault, nxJson.targetDefaults, projects, projectMap)) {
+            delete nxJson.targetDefaults[targetDefaultKey];
+        }
+    }
+    let addOutputs = false;
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/eslint:lint', (options, proj, targetName, configuration) => {
+        const projConfig = projectMap.get(proj);
+        // modify lint file patterns
+        if (options.lintFilePatterns) {
+            const projectRootRegex = new RegExp(`^${projConfig.root}/`);
+            projConfig.targets[targetName].options.lintFilePatterns =
+                options.lintFilePatterns
+                    .filter((filePattern) => filePattern !== '{projectRoot}' &&
+                    filePattern !== projConfig.root)
+                    .map((filePattern) => filePattern.replace(projectRootRegex, '{projectRoot}/'));
+            // remove lintFilePatterns if empty
+            if (projConfig.targets[targetName].options.lintFilePatterns.length === 0) {
+                delete projConfig.targets[targetName].options.lintFilePatterns;
+            }
+        }
+        // remove inputs if they are not bringing any new inputs
+        if (projConfig.targets[targetName].inputs &&
+            projConfig.targets[targetName].inputs.every((i) => lintDefaults.inputs.includes(i))) {
+            delete projConfig.targets[targetName].inputs;
+        }
+        // remove obsolete eslint config definition, unless it's a custom one
+        const projectEslintConfig = (0, eslint_file_1.findEslintFile)(tree, projConfig.root);
+        if (options.eslintConfig === `${projConfig.root}/${projectEslintConfig}` ||
+            options.eslintConfig === `{projectRoot}/${projectEslintConfig}`) {
+            delete projConfig.targets[targetName].options.eslintConfig;
+        }
+        // remove options if empty
+        if (Object.keys(projConfig.targets[targetName]?.options ?? {}).length === 0) {
+            delete projConfig.targets[targetName].options;
+        }
+        // track output
+        if (options.outputFile) {
+            addOutputs = true;
+        }
+        if (projConfig.targets[targetName].outputs?.length === 1 &&
+            projConfig.targets[targetName].outputs[0] === '{options.outputFile}') {
+            delete projConfig.targets[targetName].outputs;
+        }
+        (0, devkit_1.updateProjectConfiguration)(tree, proj, projConfig);
+    });
+    if (addOutputs) {
+        lintDefaults.outputs = ['{options.outputFile}'];
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = update;
+function isTargetDefaultUsed(targetDefault, targetDefaults, projects, projectMap) {
+    for (const p of Object.values(projects)) {
+        for (const targetName in p.data?.targets ?? {}) {
+            if ((0, project_configuration_utils_1.readTargetDefaultsForTarget)(targetName, targetDefaults, 
+            // It might seem like we should use the graph here too but we don't want to pass an executor which was processed in the graph
+            projectMap.get(p.name)?.targets?.[targetName]?.executor) === targetDefault) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/src/plugins/plugin.d.ts

@@ -0,0 +1,5 @@
+import { CreateNodes } from '@nx/devkit';
+export interface EslintPluginOptions {
+    targetName?: string;
+}
+export declare const createNodes: CreateNodes<EslintPluginOptions>;

package/src/plugins/plugin.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const globs_1 = require("nx/src/utils/globs");
+const config_file_1 = require("../utils/config-file");
+exports.createNodes = [
+    (0, globs_1.combineGlobPatterns)(['**/project.json', '**/package.json']),
+    (configFilePath, options, context) => {
+        const projectRoot = (0, path_1.dirname)(configFilePath);
+        options = normalizeOptions(options);
+        const eslintConfigs = getEslintConfigsForProject(projectRoot, context.workspaceRoot);
+        if (!eslintConfigs.length) {
+            return {};
+        }
+        return {
+            projects: {
+                [projectRoot]: {
+                    targets: buildEslintTargets(eslintConfigs, projectRoot, options),
+                },
+            },
+        };
+    },
+];
+function getEslintConfigsForProject(projectRoot, workspaceRoot) {
+    const detectedConfigs = new Set();
+    const baseConfig = (0, config_file_1.findBaseEslintFile)(workspaceRoot);
+    if (baseConfig) {
+        detectedConfigs.add(baseConfig);
+    }
+    let siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(workspaceRoot, projectRoot));
+    if (projectRoot === '.') {
+        // If there's no src folder, it's not a standalone project
+        if (!siblingFiles.includes('src')) {
+            return [];
+        }
+        // If it's standalone but doesn't have eslint config, it's not a lintable
+        const config = siblingFiles.find((f) => config_file_1.ESLINT_CONFIG_FILENAMES.includes(f));
+        if (!config) {
+            return [];
+        }
+        detectedConfigs.add(config);
+        return Array.from(detectedConfigs);
+    }
+    while (projectRoot !== '.') {
+        // if it has an eslint config it's lintable
+        const config = siblingFiles.find((f) => config_file_1.ESLINT_CONFIG_FILENAMES.includes(f));
+        if (config) {
+            detectedConfigs.add(`${projectRoot}/${config}`);
+            return Array.from(detectedConfigs);
+        }
+        projectRoot = (0, path_1.dirname)(projectRoot);
+        siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(workspaceRoot, projectRoot));
+    }
+    // check whether the root has an eslint config
+    const config = (0, fs_1.readdirSync)(workspaceRoot).find((f) => config_file_1.ESLINT_CONFIG_FILENAMES.includes(f));
+    if (config) {
+        detectedConfigs.add(config);
+        return Array.from(detectedConfigs);
+    }
+    return [];
+}
+function buildEslintTargets(eslintConfigs, projectRoot, options) {
+    const isRootProject = projectRoot === '.';
+    const targets = {};
+    const targetConfig = {
+        command: `eslint ${isRootProject ? './src' : '.'}`,
+        cache: true,
+        options: {
+            cwd: projectRoot,
+        },
+        inputs: [
+            'default',
+            ...eslintConfigs.map((config) => `{workspaceRoot}/${config}`),
+            '{workspaceRoot}/tools/eslint-rules/**/*',
+            { externalDependencies: ['eslint'] },
+        ],
+    };
+    if (eslintConfigs.some((config) => (0, config_file_1.isFlatConfig)(config))) {
+        targetConfig.options.env = {
+            ESLINT_USE_FLAT_CONFIG: 'true',
+        };
+    }
+    targets[options.targetName] = targetConfig;
+    return targets;
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.targetName ??= 'lint';
+    return options;
+}

package/src/utils/config-file.d.ts

@@ -0,0 +1,5 @@
+export declare const ESLINT_CONFIG_FILENAMES: string[];
+export declare const baseEsLintConfigFile = ".eslintrc.base.json";
+export declare const baseEsLintFlatConfigFile = "eslint.base.config.js";
+export declare function findBaseEslintFile(workspaceRoot?: string): string | null;
+export declare function isFlatConfig(configFilePath: string): boolean;

package/src/utils/config-file.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFlatConfig = exports.findBaseEslintFile = exports.baseEsLintFlatConfigFile = exports.baseEsLintConfigFile = exports.ESLINT_CONFIG_FILENAMES = void 0;
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+exports.ESLINT_CONFIG_FILENAMES = [
+    '.eslintrc',
+    '.eslintrc.js',
+    '.eslintrc.cjs',
+    '.eslintrc.yaml',
+    '.eslintrc.yml',
+    '.eslintrc.json',
+    'eslint.config.js',
+];
+exports.baseEsLintConfigFile = '.eslintrc.base.json';
+exports.baseEsLintFlatConfigFile = 'eslint.base.config.js';
+function findBaseEslintFile(workspaceRoot = '') {
+    if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(workspaceRoot, exports.baseEsLintConfigFile))) {
+        return exports.baseEsLintConfigFile;
+    }
+    if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(workspaceRoot, exports.baseEsLintFlatConfigFile))) {
+        return exports.baseEsLintFlatConfigFile;
+    }
+    for (const file of exports.ESLINT_CONFIG_FILENAMES) {
+        if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(workspaceRoot, file))) {
+            return file;
+        }
+    }
+    return null;
+}
+exports.findBaseEslintFile = findBaseEslintFile;
+function isFlatConfig(configFilePath) {
+    return configFilePath.endsWith('.config.js');
+}
+exports.isFlatConfig = isFlatConfig;

package/src/utils/flat-config.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function useFlatConfig(tree: Tree): boolean;

package/src/utils/flat-config.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFlatConfig = void 0;
+function useFlatConfig(tree) {
+    return tree.exists('eslint.config.js');
+}
+exports.useFlatConfig = useFlatConfig;

package/src/utils/rules-requiring-type-checking.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from 'eslint';
+export declare function hasRulesRequiringTypeChecking(eslintConfig: Linter.Config): boolean;
+export declare function removeParserOptionsProjectIfNotRequired(json: Linter.Config): Linter.Config;

package/src/utils/rules-requiring-type-checking.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeParserOptionsProjectIfNotRequired = exports.hasRulesRequiringTypeChecking = void 0;
+// 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));
+}
+exports.hasRulesRequiringTypeChecking = hasRulesRequiringTypeChecking;
+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;
+}
+exports.removeParserOptionsProjectIfNotRequired = removeParserOptionsProjectIfNotRequired;
+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;
+            }
+        }
+    }
+}

package/src/utils/versions.d.ts

@@ -0,0 +1,5 @@
+export declare const nxVersion: any;
+export declare const eslintVersion = "~8.48.0";
+export declare const eslintrcVersion = "^2.1.1";
+export declare const eslintConfigPrettierVersion = "^9.0.0";
+export declare const typescriptESLintVersion = "^6.13.2";

package/src/utils/versions.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescriptESLintVersion = exports.eslintConfigPrettierVersion = exports.eslintrcVersion = exports.eslintVersion = exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;
+exports.eslintVersion = '~8.48.0';
+exports.eslintrcVersion = '^2.1.1';
+exports.eslintConfigPrettierVersion = '^9.0.0';
+exports.typescriptESLintVersion = '^6.13.2';

package/src/utils/workspace-lint-rules.d.ts

@@ -0,0 +1 @@
+export declare const workspaceLintPluginDir: string;

package/src/utils/workspace-lint-rules.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceLintPluginDir = void 0;
+const devkit_1 = require("@nx/devkit");
+exports.workspaceLintPluginDir = (0, devkit_1.joinPathFragments)('tools/eslint-rules');