@nx/eslint 17.0.0-beta.8

package/src/generators/init/init.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintInitGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../utils/versions");
+const eslint_file_1 = require("../utils/eslint-file");
+const global_eslint_config_1 = require("./global-eslint-config");
+function addTargetDefaults(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const productionFileSet = nxJson.namedInputs?.production;
+    if (productionFileSet) {
+        // Remove .eslintrc.json
+        productionFileSet.push('!{projectRoot}/.eslintrc.json');
+        productionFileSet.push('!{projectRoot}/eslint.config.js');
+        // Dedupe and set
+        nxJson.namedInputs.production = Array.from(new Set(productionFileSet));
+    }
+    nxJson.targetDefaults ??= {};
+    nxJson.targetDefaults.lint ??= {};
+    nxJson.targetDefaults.lint.inputs ??= [
+        'default',
+        `{workspaceRoot}/.eslintrc.json`,
+        `{workspaceRoot}/.eslintignore`,
+        `{workspaceRoot}/eslint.config.js`,
+    ];
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+/**
+ * Initializes ESLint configuration in a workspace and adds necessary dependencies.
+ */
+function initEsLint(tree, options) {
+    if ((0, eslint_file_1.findEslintFile)(tree)) {
+        return () => { };
+    }
+    if (!options.skipPackageJson) {
+        (0, devkit_1.removeDependenciesFromPackageJson)(tree, ['@nx/eslint'], []);
+    }
+    (0, devkit_1.writeJson)(tree, '.eslintrc.json', (0, global_eslint_config_1.getGlobalEsLintConfiguration)(options.unitTestRunner, options.rootProject));
+    tree.write('.eslintignore', 'node_modules\n');
+    addTargetDefaults(tree);
+    if (tree.exists('.vscode/extensions.json')) {
+        (0, devkit_1.updateJson)(tree, '.vscode/extensions.json', (json) => {
+            json.recommendations ||= [];
+            const extension = 'dbaeumer.vscode-eslint';
+            if (!json.recommendations.includes(extension)) {
+                json.recommendations.push(extension);
+            }
+            return json;
+        });
+    }
+    return !options.skipPackageJson
+        ? (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/eslint': versions_1.nxVersion,
+            '@nx/eslint-plugin': versions_1.nxVersion,
+            '@typescript-eslint/parser': versions_1.typescriptESLintVersion,
+            '@typescript-eslint/eslint-plugin': versions_1.typescriptESLintVersion,
+            eslint: versions_1.eslintVersion,
+            'eslint-config-prettier': versions_1.eslintConfigPrettierVersion,
+        })
+        : () => { };
+}
+function lintInitGenerator(tree, options) {
+    return initEsLint(tree, options);
+}
+exports.lintInitGenerator = lintInitGenerator;

package/src/generators/lint-project/lint-project.d.ts

@@ -0,0 +1,16 @@
+import type { Tree } from '@nx/devkit';
+import { Linter as LinterEnum } from '../utils/linter';
+interface LintProjectOptions {
+    project: string;
+    linter?: LinterEnum;
+    eslintFilePatterns?: string[];
+    tsConfigPaths?: string[];
+    skipFormat: boolean;
+    setParserOptionsProject?: boolean;
+    skipPackageJson?: boolean;
+    unitTestRunner?: string;
+    rootProject?: boolean;
+}
+export declare function mapLintPattern(projectRoot: string, extension: string, rootProject?: boolean): string;
+export declare function lintProjectGenerator(tree: Tree, options: LintProjectOptions): Promise<import("@nx/devkit").GeneratorCallback>;
+export {};

package/src/generators/lint-project/lint-project.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintProjectGenerator = exports.mapLintPattern = void 0;
+const devkit_1 = require("@nx/devkit");
+const eslint_file_1 = require("../utils/eslint-file");
+const path_1 = require("path");
+const init_1 = require("../init/init");
+const init_migration_1 = require("../init/init-migration");
+const project_configuration_1 = require("nx/src/generators/utils/project-configuration");
+const flat_config_1 = require("../../utils/flat-config");
+const ast_utils_1 = require("../utils/flat-config/ast-utils");
+function mapLintPattern(projectRoot, extension, rootProject) {
+    if (rootProject && (projectRoot === '.' || projectRoot === '')) {
+        return `${projectRoot}/src/**/*.${extension}`;
+    }
+    else {
+        return `${projectRoot}/**/*.${extension}`;
+    }
+}
+exports.mapLintPattern = mapLintPattern;
+async function lintProjectGenerator(tree, options) {
+    const installTask = (0, init_1.lintInitGenerator)(tree, {
+        linter: options.linter,
+        unitTestRunner: options.unitTestRunner,
+        skipPackageJson: options.skipPackageJson,
+        rootProject: options.rootProject,
+    });
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const lintFilePatterns = options.eslintFilePatterns ?? [];
+    if (isBuildableLibraryProject(projectConfig)) {
+        lintFilePatterns.push(`${projectConfig.root}/package.json`);
+    }
+    projectConfig.targets['lint'] = {
+        executor: '@nx/eslint:lint',
+        outputs: ['{options.outputFile}'],
+        options: {
+            lintFilePatterns: lintFilePatterns,
+        },
+    };
+    // we are adding new project which is not the root project or
+    // companion e2e app so we should check if migration to
+    // monorepo style is needed
+    if (!options.rootProject) {
+        const projects = {};
+        (0, project_configuration_1.getProjects)(tree).forEach((v, k) => (projects[k] = v));
+        if (isMigrationToMonorepoNeeded(projects, tree)) {
+            // we only migrate project configurations that have been created
+            const filteredProjects = [];
+            Object.entries(projects).forEach(([name, project]) => {
+                if (name !== options.project) {
+                    filteredProjects.push(project);
+                }
+            });
+            (0, init_migration_1.migrateConfigToMonorepoStyle)(filteredProjects, tree, options.unitTestRunner);
+        }
+    }
+    // our root `.eslintrc` is already the project config, so we should not override it
+    // additionally, the companion e2e app would have `rootProject: true`
+    // so we need to check for the root path as well
+    if (!options.rootProject || projectConfig.root !== '.') {
+        createEsLintConfiguration(tree, projectConfig, options.setParserOptionsProject);
+    }
+    // Buildable libs need source analysis enabled for linting `package.json`.
+    if (isBuildableLibraryProject(projectConfig) &&
+        !isJsAnalyzeSourceFilesEnabled(tree)) {
+        (0, devkit_1.updateJson)(tree, 'nx.json', (json) => {
+            json.pluginsConfig ??= {};
+            json.pluginsConfig['@nx/js'] ??= {};
+            json.pluginsConfig['@nx/js'].analyzeSourceFiles = true;
+            return json;
+        });
+    }
+    (0, devkit_1.updateProjectConfiguration)(tree, options.project, projectConfig);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return installTask;
+}
+exports.lintProjectGenerator = lintProjectGenerator;
+function createEsLintConfiguration(tree, projectConfig, setParserOptionsProject) {
+    const eslintConfig = (0, eslint_file_1.findEslintFile)(tree);
+    const pathToRootConfig = eslintConfig
+        ? `${(0, devkit_1.offsetFromRoot)(projectConfig.root)}${eslintConfig}`
+        : undefined;
+    const addDependencyChecks = isBuildableLibraryProject(projectConfig);
+    const overrides = [
+        {
+            files: ['*.ts', '*.tsx', '*.js', '*.jsx'],
+            /**
+             * NOTE: We no longer set parserOptions.project by default when creating new projects.
+             *
+             * We have observed that users rarely add rules requiring type-checking to their Nx workspaces, and therefore
+             * do not actually need the capabilites which parserOptions.project provides. When specifying parserOptions.project,
+             * typescript-eslint needs to create full TypeScript Programs for you. When omitting it, it can perform a simple
+             * parse (and AST tranformation) of the source files it encounters during a lint run, which is much faster and much
+             * less memory intensive.
+             *
+             * In the rare case that users attempt to add rules requiring type-checking to their setup later on (and haven't set
+             * parserOptions.project), the executor will attempt to look for the particular error typescript-eslint gives you
+             * and provide feedback to the user.
+             */
+            parserOptions: !setParserOptionsProject
+                ? undefined
+                : {
+                    project: [`${projectConfig.root}/tsconfig.*?.json`],
+                },
+            /**
+             * Having an empty rules object present makes it more obvious to the user where they would
+             * extend things from if they needed to
+             */
+            rules: {},
+        },
+        {
+            files: ['*.ts', '*.tsx'],
+            rules: {},
+        },
+        {
+            files: ['*.js', '*.jsx'],
+            rules: {},
+        },
+    ];
+    if (isBuildableLibraryProject(projectConfig)) {
+        overrides.push({
+            files: ['*.json'],
+            parser: 'jsonc-eslint-parser',
+            rules: {
+                '@nx/dependency-checks': 'error',
+            },
+        });
+    }
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const isCompatNeeded = addDependencyChecks;
+        const nodes = [];
+        const importMap = new Map();
+        if (eslintConfig) {
+            importMap.set(pathToRootConfig, 'baseConfig');
+            nodes.push((0, ast_utils_1.generateSpreadElement)('baseConfig'));
+        }
+        overrides.forEach((override) => {
+            nodes.push((0, ast_utils_1.generateFlatOverride)(override, projectConfig.root));
+        });
+        const nodeList = (0, ast_utils_1.createNodeList)(importMap, nodes, isCompatNeeded);
+        const content = (0, ast_utils_1.stringifyNodeList)(nodeList, projectConfig.root, 'eslint.config.js');
+        tree.write((0, path_1.join)(projectConfig.root, 'eslint.config.js'), content);
+    }
+    else {
+        (0, devkit_1.writeJson)(tree, (0, path_1.join)(projectConfig.root, `.eslintrc.json`), {
+            extends: eslintConfig ? [pathToRootConfig] : undefined,
+            // Include project files to be linted since the global one excludes all files.
+            ignorePatterns: ['!**/*'],
+            overrides,
+        });
+    }
+}
+function isJsAnalyzeSourceFilesEnabled(tree) {
+    const nxJson = (0, devkit_1.readJson)(tree, 'nx.json');
+    const jsPluginConfig = nxJson.pluginsConfig?.['@nx/js'];
+    return (jsPluginConfig?.analyzeSourceFiles ??
+        nxJson.extends !== 'nx/presets/npm.json');
+}
+function isBuildableLibraryProject(projectConfig) {
+    return (projectConfig.projectType === 'library' &&
+        projectConfig.targets?.build &&
+        !!projectConfig.targets.build);
+}
+/**
+ * Detect based on the state of lint target configuration of the root project
+ * if we should migrate eslint configs to monorepo style
+ */
+function isMigrationToMonorepoNeeded(projects, tree) {
+    // the base config is already created, migration has been done
+    if (tree.exists(eslint_file_1.baseEsLintConfigFile) ||
+        tree.exists(eslint_file_1.baseEsLintFlatConfigFile)) {
+        return false;
+    }
+    const configs = Object.values(projects);
+    if (configs.length === 1) {
+        return false;
+    }
+    // get root project
+    const rootProject = configs.find((p) => p.root === '.');
+    if (!rootProject || !rootProject.targets) {
+        return false;
+    }
+    // find if root project has lint target
+    const lintTarget = (0, init_migration_1.findLintTarget)(rootProject);
+    if (!lintTarget) {
+        return false;
+    }
+    return true;
+}

package/src/generators/utils/eslint-file.d.ts

@@ -0,0 +1,19 @@
+import { Tree } from '@nx/devkit';
+import { Linter } from 'eslint';
+export declare const eslintConfigFileWhitelist: string[];
+export declare const baseEsLintConfigFile = ".eslintrc.base.json";
+export declare const baseEsLintFlatConfigFile = "eslint.base.config.js";
+export declare function findEslintFile(tree: Tree, projectRoot?: string): string | null;
+export declare function isEslintConfigSupported(tree: Tree, projectRoot?: string): boolean;
+export declare function updateRelativePathsInConfig(tree: Tree, sourcePath: string, destinationPath: string): void;
+export declare function addOverrideToLintConfig(tree: Tree, root: string, override: Linter.ConfigOverride<Linter.RulesRecord>, options?: {
+    insertAtTheEnd?: boolean;
+    checkBaseConfig?: boolean;
+}): void;
+export declare function updateOverrideInLintConfig(tree: Tree, root: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean, update: (override: Linter.ConfigOverride<Linter.RulesRecord>) => Linter.ConfigOverride<Linter.RulesRecord>): void;
+export declare function lintConfigHasOverride(tree: Tree, root: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean, checkBaseConfig?: boolean): boolean;
+export declare function replaceOverridesInLintConfig(tree: Tree, root: string, overrides: Linter.ConfigOverride<Linter.RulesRecord>[]): void;
+export declare function addExtendsToLintConfig(tree: Tree, root: string, plugin: string | string[]): void;
+export declare function addPluginsToLintConfig(tree: Tree, root: string, plugin: string | string[]): void;
+export declare function addIgnoresToLintConfig(tree: Tree, root: string, ignorePatterns: string[]): void;
+export declare function getPluginImport(pluginName: string): string;

package/src/generators/utils/eslint-file.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPluginImport = exports.addIgnoresToLintConfig = exports.addPluginsToLintConfig = exports.addExtendsToLintConfig = exports.replaceOverridesInLintConfig = exports.lintConfigHasOverride = exports.updateOverrideInLintConfig = exports.addOverrideToLintConfig = exports.updateRelativePathsInConfig = exports.isEslintConfigSupported = exports.findEslintFile = exports.baseEsLintFlatConfigFile = exports.baseEsLintConfigFile = exports.eslintConfigFileWhitelist = void 0;
+const devkit_1 = require("@nx/devkit");
+const flat_config_1 = require("../../utils/flat-config");
+const ast_utils_1 = require("./flat-config/ast-utils");
+exports.eslintConfigFileWhitelist = [
+    '.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 findEslintFile(tree, projectRoot = '') {
+    if (projectRoot === '' && tree.exists(exports.baseEsLintConfigFile)) {
+        return exports.baseEsLintConfigFile;
+    }
+    if (projectRoot === '' && tree.exists(exports.baseEsLintFlatConfigFile)) {
+        return exports.baseEsLintFlatConfigFile;
+    }
+    for (const file of exports.eslintConfigFileWhitelist) {
+        if (tree.exists((0, devkit_1.joinPathFragments)(projectRoot, file))) {
+            return file;
+        }
+    }
+    return null;
+}
+exports.findEslintFile = findEslintFile;
+function isEslintConfigSupported(tree, projectRoot = '') {
+    const eslintFile = findEslintFile(tree, projectRoot);
+    if (!eslintFile) {
+        return false;
+    }
+    return eslintFile.endsWith('.json') || eslintFile.endsWith('.config.js');
+}
+exports.isEslintConfigSupported = isEslintConfigSupported;
+function updateRelativePathsInConfig(tree, sourcePath, destinationPath) {
+    if (sourcePath === destinationPath ||
+        !isEslintConfigSupported(tree, destinationPath)) {
+        return;
+    }
+    const configPath = (0, devkit_1.joinPathFragments)(destinationPath, findEslintFile(tree, destinationPath));
+    const offset = (0, devkit_1.offsetFromRoot)(destinationPath);
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const config = tree.read(configPath, 'utf-8');
+        tree.write(configPath, replaceFlatConfigPaths(config, sourcePath, offset, destinationPath));
+    }
+    else {
+        (0, devkit_1.updateJson)(tree, configPath, (json) => {
+            if (typeof json.extends === 'string') {
+                json.extends = offsetFilePath(sourcePath, json.extends, offset);
+            }
+            else if (json.extends) {
+                json.extends = json.extends.map((extend) => offsetFilePath(sourcePath, extend, offset));
+            }
+            json.overrides?.forEach((o) => {
+                if (o.parserOptions?.project) {
+                    o.parserOptions.project = Array.isArray(o.parserOptions.project)
+                        ? o.parserOptions.project.map((p) => p.replace(sourcePath, destinationPath))
+                        : o.parserOptions.project.replace(sourcePath, destinationPath);
+                }
+            });
+            return json;
+        });
+    }
+}
+exports.updateRelativePathsInConfig = updateRelativePathsInConfig;
+function replaceFlatConfigPaths(config, sourceRoot, offset, destinationRoot) {
+    let match;
+    let newConfig = config;
+    // replace requires
+    const requireRegex = RegExp(/require\(['"](.*)['"]\)/g);
+    while ((match = requireRegex.exec(newConfig)) !== null) {
+        const newPath = offsetFilePath(sourceRoot, match[1], offset);
+        newConfig =
+            newConfig.slice(0, match.index) +
+                `require('${newPath}')` +
+                newConfig.slice(match.index + match[0].length);
+    }
+    // replace projects
+    const projectRegex = RegExp(/project:\s?\[?['"](.*)['"]\]?/g);
+    while ((match = projectRegex.exec(newConfig)) !== null) {
+        const newProjectDef = match[0].replaceAll(sourceRoot, destinationRoot);
+        newConfig =
+            newConfig.slice(0, match.index) +
+                newProjectDef +
+                newConfig.slice(match.index + match[0].length);
+    }
+    return newConfig;
+}
+function offsetFilePath(projectRoot, pathToFile, offset) {
+    if (!pathToFile.startsWith('..')) {
+        // not a relative path
+        return pathToFile;
+    }
+    return (0, devkit_1.joinPathFragments)(offset, projectRoot, pathToFile);
+}
+function addOverrideToLintConfig(tree, root, override, options = {
+    insertAtTheEnd: true,
+}) {
+    const isBase = options.checkBaseConfig && findEslintFile(tree, root).includes('.base');
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, isBase ? exports.baseEsLintFlatConfigFile : 'eslint.config.js');
+        const flatOverride = (0, ast_utils_1.generateFlatOverride)(override, root);
+        let content = tree.read(fileName, 'utf8');
+        // we will be using compat here so we need to make sure it's added
+        if (overrideNeedsCompat(override)) {
+            content = (0, ast_utils_1.addCompatToFlatConfig)(content);
+        }
+        tree.write(fileName, (0, ast_utils_1.addBlockToFlatConfigExport)(content, flatOverride, options));
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, isBase ? exports.baseEsLintConfigFile : '.eslintrc.json');
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            json.overrides ?? [];
+            if (options.insertAtTheEnd) {
+                json.overrides.push(override);
+            }
+            else {
+                json.overrides.unshift(override);
+            }
+            return json;
+        });
+    }
+}
+exports.addOverrideToLintConfig = addOverrideToLintConfig;
+function overrideNeedsCompat(override) {
+    return (!override.env && !override.extends && !override.plugins && !override.parser);
+}
+function updateOverrideInLintConfig(tree, root, lookup, update) {
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, 'eslint.config.js');
+        let content = tree.read(fileName, 'utf8');
+        content = (0, ast_utils_1.replaceOverride)(content, root, lookup, update);
+        tree.write(fileName, content);
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, '.eslintrc.json');
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            const index = json.overrides.findIndex(lookup);
+            if (index !== -1) {
+                json.overrides[index] = update(json.overrides[index]);
+            }
+            return json;
+        });
+    }
+}
+exports.updateOverrideInLintConfig = updateOverrideInLintConfig;
+function lintConfigHasOverride(tree, root, lookup, checkBaseConfig = false) {
+    if (!isEslintConfigSupported(tree, root)) {
+        return false;
+    }
+    const isBase = checkBaseConfig && findEslintFile(tree, root).includes('.base');
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, isBase ? exports.baseEsLintFlatConfigFile : 'eslint.config.js');
+        const content = tree.read(fileName, 'utf8');
+        return (0, ast_utils_1.hasOverride)(content, lookup);
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, isBase ? exports.baseEsLintConfigFile : '.eslintrc.json');
+        return (0, devkit_1.readJson)(tree, fileName).overrides?.some(lookup) || false;
+    }
+}
+exports.lintConfigHasOverride = lintConfigHasOverride;
+function replaceOverridesInLintConfig(tree, root, overrides) {
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, 'eslint.config.js');
+        let content = tree.read(fileName, 'utf8');
+        // we will be using compat here so we need to make sure it's added
+        if (overrides.some(overrideNeedsCompat)) {
+            content = (0, ast_utils_1.addCompatToFlatConfig)(content);
+        }
+        content = (0, ast_utils_1.removeOverridesFromLintConfig)(content);
+        overrides.forEach((override) => {
+            const flatOverride = (0, ast_utils_1.generateFlatOverride)(override, root);
+            (0, ast_utils_1.addBlockToFlatConfigExport)(content, flatOverride);
+        });
+        tree.write(fileName, content);
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, '.eslintrc.json');
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            json.overrides = overrides;
+            return json;
+        });
+    }
+}
+exports.replaceOverridesInLintConfig = replaceOverridesInLintConfig;
+function addExtendsToLintConfig(tree, root, plugin) {
+    const plugins = Array.isArray(plugin) ? plugin : [plugin];
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, 'eslint.config.js');
+        const pluginExtends = (0, ast_utils_1.generatePluginExtendsElement)(plugins);
+        tree.write(fileName, (0, ast_utils_1.addBlockToFlatConfigExport)(tree.read(fileName, 'utf8'), pluginExtends));
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, '.eslintrc.json');
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            json.extends = [...plugins, ...(json.extends ?? [])];
+            return json;
+        });
+    }
+}
+exports.addExtendsToLintConfig = addExtendsToLintConfig;
+function addPluginsToLintConfig(tree, root, plugin) {
+    const plugins = Array.isArray(plugin) ? plugin : [plugin];
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, 'eslint.config.js');
+        let content = tree.read(fileName, 'utf8');
+        const mappedPlugins = [];
+        plugins.forEach((name) => {
+            const imp = getPluginImport(name);
+            const varName = (0, devkit_1.names)(imp).propertyName;
+            mappedPlugins.push({ name, varName, imp });
+        });
+        mappedPlugins.forEach(({ varName, imp }) => {
+            content = (0, ast_utils_1.addImportToFlatConfig)(content, varName, imp);
+        });
+        content = (0, ast_utils_1.addPluginsToExportsBlock)(content, mappedPlugins);
+        tree.write(fileName, content);
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, '.eslintrc.json');
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            json.plugins = [...plugins, ...(json.plugins ?? [])];
+            return json;
+        });
+    }
+}
+exports.addPluginsToLintConfig = addPluginsToLintConfig;
+function addIgnoresToLintConfig(tree, root, ignorePatterns) {
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, 'eslint.config.js');
+        const block = (0, ast_utils_1.generateAst)({
+            ignores: ignorePatterns.map((path) => (0, ast_utils_1.mapFilePath)(path, root)),
+        });
+        tree.write(fileName, (0, ast_utils_1.addBlockToFlatConfigExport)(tree.read(fileName, 'utf8'), block));
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, '.eslintrc.json');
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            const ignoreSet = new Set([
+                ...(json.ignorePatterns ?? []),
+                ...ignorePatterns,
+            ]);
+            json.ignorePatterns = Array.from(ignoreSet);
+            return json;
+        });
+    }
+}
+exports.addIgnoresToLintConfig = addIgnoresToLintConfig;
+function getPluginImport(pluginName) {
+    if (pluginName.includes('eslint-plugin-')) {
+        return pluginName;
+    }
+    if (!pluginName.startsWith('@')) {
+        return `eslint-plugin-${pluginName}`;
+    }
+    if (!pluginName.includes('/')) {
+        return `${pluginName}/eslint-plugin`;
+    }
+    const [scope, name] = pluginName.split('/');
+    return `${scope}/eslint-plugin-${name}`;
+}
+exports.getPluginImport = getPluginImport;

package/src/generators/utils/eslint-targets.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function getEslintTargets(tree: Tree): Set<string>;

package/src/generators/utils/eslint-targets.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEslintTargets = void 0;
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+function getEslintTargets(tree) {
+    const eslintTargetNames = new Set();
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/eslint:lint', (_, __, target) => {
+        eslintTargetNames.add(target);
+    });
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/linter:eslint', (_, __, target) => {
+        eslintTargetNames.add(target);
+    });
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/linter:eslint', (_, __, target) => {
+        eslintTargetNames.add(target);
+    });
+    return eslintTargetNames;
+}
+exports.getEslintTargets = getEslintTargets;

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

@@ -0,0 +1,61 @@
+import { Linter } from 'eslint';
+import * as ts from 'typescript';
+/**
+ * Remove all overrides from the config file
+ */
+export declare function removeOverridesFromLintConfig(content: string): string;
+export declare function hasOverride(content: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean): boolean;
+/**
+ * Finds an override matching the lookup function and applies the update function to it
+ */
+export declare function replaceOverride(content: string, root: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean, update: (override: Linter.ConfigOverride<Linter.RulesRecord>) => Linter.ConfigOverride<Linter.RulesRecord>): string;
+/**
+ * Adding require statement to the top of the file
+ */
+export declare function addImportToFlatConfig(content: string, variable: string | string[], imp: string): string;
+/**
+ * Injects new ts.expression to the end of the module.exports array.
+ */
+export declare function addBlockToFlatConfigExport(content: string, config: ts.Expression | ts.SpreadElement, options?: {
+    insertAtTheEnd?: boolean;
+    checkBaseConfig?: boolean;
+}): string;
+export declare function removePlugin(content: string, pluginName: string, pluginImport: string): string;
+export declare function removeCompatExtends(content: string, compatExtends: string[]): string;
+/**
+ * Add plugins block to the top of the export blocks
+ */
+export declare function addPluginsToExportsBlock(content: string, plugins: {
+    name: string;
+    varName: string;
+    imp: string;
+}[]): string;
+/**
+ * Adds compat if missing to flat config
+ */
+export declare function addCompatToFlatConfig(content: string): string;
+/**
+ * Generate node list representing the imports and the exports blocks
+ * Optionally add flat compat initialization
+ */
+export declare function createNodeList(importsMap: Map<string, string>, exportElements: ts.Expression[], isFlatCompatNeeded: boolean): ts.NodeArray<ts.VariableStatement | ts.Identifier | ts.ExpressionStatement | ts.SourceFile>;
+export declare function generateSpreadElement(name: string): ts.SpreadElement;
+export declare function generatePluginExtendsElement(plugins: string[]): ts.SpreadElement;
+/**
+ * Stringifies TS nodes to file content string
+ */
+export declare function stringifyNodeList(nodes: ts.NodeArray<ts.VariableStatement | ts.Identifier | ts.ExpressionStatement | ts.SourceFile>, root: string, fileName: string): string;
+/**
+ * generates AST require statement
+ */
+export declare function generateRequire(variableName: string | ts.ObjectBindingPattern, imp: string): ts.VariableStatement;
+/**
+ * Generates AST object or spread element based on JSON override object
+ */
+export declare function generateFlatOverride(override: Linter.ConfigOverride<Linter.RulesRecord>, root: string): ts.ObjectLiteralExpression | ts.SpreadElement;
+export declare function mapFilePaths(override: Linter.ConfigOverride<Linter.RulesRecord>, root: string): void;
+export declare function mapFilePath(filePath: string, root: string): string;
+/**
+ * Generates an AST from a JSON-type input
+ */
+export declare function generateAst<T>(input: unknown): T;