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

package/src/generators/init/global-eslint-config.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalFlatEslintConfiguration = exports.getGlobalEsLintConfiguration = exports.javaScriptOverride = exports.typeScriptOverride = void 0;
+const ast_utils_1 = require("../utils/flat-config/ast-utils");
+/**
+ * This configuration is intended to apply to all TypeScript source files.
+ * See the eslint-plugin package for what is in the referenced shareable config.
+ */
+exports.typeScriptOverride = {
+    files: ['*.ts', '*.tsx'],
+    extends: ['plugin:@nx/typescript'],
+    /**
+     * Having an empty rules object present makes it more obvious to the user where they would
+     * extend things from if they needed to
+     */
+    rules: {},
+};
+/**
+ * This configuration is intended to apply to all JavaScript source files.
+ * See the eslint-plugin package for what is in the referenced shareable config.
+ */
+exports.javaScriptOverride = {
+    files: ['*.js', '*.jsx'],
+    extends: ['plugin:@nx/javascript'],
+    /**
+     * Having an empty rules object present makes it more obvious to the user where they would
+     * extend things from if they needed to
+     */
+    rules: {},
+};
+/**
+ * This configuration is intended to apply to all "source code" (but not
+ * markup like HTML, or other custom file types like GraphQL)
+ */
+const moduleBoundariesOverride = {
+    files: ['*.ts', '*.tsx', '*.js', '*.jsx'],
+    rules: {
+        '@nx/enforce-module-boundaries': [
+            'error',
+            {
+                enforceBuildableLibDependency: true,
+                allow: [],
+                depConstraints: [{ sourceTag: '*', onlyDependOnLibsWithTags: ['*'] }],
+            },
+        ],
+    },
+};
+/**
+ * This configuration is intended to apply to all "source code" (but not
+ * markup like HTML, or other custom file types like GraphQL)
+ */
+const jestOverride = {
+    files: ['*.spec.ts', '*.spec.tsx', '*.spec.js', '*.spec.jsx'],
+    env: {
+        jest: true,
+    },
+    rules: {},
+};
+const getGlobalEsLintConfiguration = (unitTestRunner, rootProject) => {
+    const config = {
+        root: true,
+        ignorePatterns: rootProject ? ['!**/*'] : ['**/*'],
+        plugins: ['@nx'],
+        /**
+         * We leverage ESLint's "overrides" capability so that we can set up a root config which will support
+         * all permutations of Nx workspaces across all frameworks, libraries and tools.
+         *
+         * The key point is that we need entirely different ESLint config to apply to different types of files,
+         * but we still want to share common config where possible.
+         */
+        overrides: [
+            ...(rootProject ? [] : [moduleBoundariesOverride]),
+            exports.typeScriptOverride,
+            exports.javaScriptOverride,
+            ...(unitTestRunner === 'jest' ? [jestOverride] : []),
+        ],
+    };
+    return config;
+};
+exports.getGlobalEsLintConfiguration = getGlobalEsLintConfiguration;
+const getGlobalFlatEslintConfiguration = (unitTestRunner, rootProject) => {
+    const nodeList = (0, ast_utils_1.createNodeList)(new Map(), [], true);
+    let content = (0, ast_utils_1.stringifyNodeList)(nodeList);
+    content = (0, ast_utils_1.addImportToFlatConfig)(content, 'nxPlugin', '@nx/eslint-plugin');
+    content = (0, ast_utils_1.addPluginsToExportsBlock)(content, [
+        { name: '@nx', varName: 'nxPlugin', imp: '@nx/eslint-plugin' },
+    ]);
+    if (!rootProject) {
+        content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatOverride)(moduleBoundariesOverride));
+    }
+    content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatOverride)(exports.typeScriptOverride));
+    content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatOverride)(exports.javaScriptOverride));
+    if (unitTestRunner === 'jest') {
+        content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatOverride)(jestOverride));
+    }
+    // add ignore for .nx folder
+    content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateAst)({
+        ignores: ['.nx'],
+    }));
+    return content;
+};
+exports.getGlobalFlatEslintConfiguration = getGlobalFlatEslintConfiguration;

package/src/generators/init/init-migration.d.ts

@@ -0,0 +1,3 @@
+import { ProjectConfiguration, TargetConfiguration, Tree } from '@nx/devkit';
+export declare function migrateConfigToMonorepoStyle(projects: ProjectConfiguration[], tree: Tree, unitTestRunner: string, keepExistingVersions?: boolean): void;
+export declare function findLintTarget(project: ProjectConfiguration): TargetConfiguration;

package/src/generators/init/init-migration.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLintTarget = exports.migrateConfigToMonorepoStyle = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const eslint_file_1 = require("../utils/eslint-file");
+const global_eslint_config_1 = require("./global-eslint-config");
+const flat_config_1 = require("../../utils/flat-config");
+const versions_1 = require("../../utils/versions");
+const ast_utils_1 = require("../utils/flat-config/ast-utils");
+const plugin_1 = require("../utils/plugin");
+const config_file_1 = require("../../utils/config-file");
+function migrateConfigToMonorepoStyle(projects, tree, unitTestRunner, keepExistingVersions) {
+    const rootEslintConfig = (0, eslint_file_1.findEslintFile)(tree);
+    let skipCleanup = false;
+    if (rootEslintConfig?.match(/\.base\./) &&
+        !projects.some((p) => p.root === '.')) {
+        // if the migration has been run already, we need to rename the base config
+        // and only update the extends paths
+        tree.rename(rootEslintConfig, rootEslintConfig.replace('.base.', '.'));
+        skipCleanup = true;
+    }
+    else {
+        if ((0, flat_config_1.useFlatConfig)(tree)) {
+            // we need this for the compat
+            (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+                '@eslint/js': versions_1.eslintVersion,
+            }, undefined, keepExistingVersions);
+            tree.write(tree.exists('eslint.config.js')
+                ? 'eslint.base.config.js'
+                : 'eslint.config.js', (0, global_eslint_config_1.getGlobalFlatEslintConfiguration)(unitTestRunner));
+        }
+        else {
+            const eslintFile = (0, eslint_file_1.findEslintFile)(tree, '.');
+            (0, devkit_1.writeJson)(tree, eslintFile ? '.eslintrc.base.json' : '.eslintrc.json', (0, global_eslint_config_1.getGlobalEsLintConfiguration)(unitTestRunner));
+        }
+    }
+    // update extends in all projects' eslint configs
+    projects.forEach((project) => {
+        let eslintFile;
+        const lintTarget = findLintTarget(project);
+        if (lintTarget) {
+            // If target is configured in project.json, read file from target options.
+            eslintFile =
+                lintTarget.options?.eslintConfig || (0, eslint_file_1.findEslintFile)(tree, project.root);
+        }
+        else if ((0, plugin_1.hasEslintPlugin)(tree)) {
+            // Otherwise, if `@nx/eslint/plugin` is used, match any of the known config files.
+            for (const f of config_file_1.ESLINT_CONFIG_FILENAMES) {
+                if (tree.exists((0, devkit_1.joinPathFragments)(project.root, f))) {
+                    eslintFile = f;
+                    break;
+                }
+            }
+        }
+        if (eslintFile) {
+            const projectEslintPath = (0, devkit_1.joinPathFragments)(project.root, eslintFile);
+            if (skipCleanup) {
+                const content = tree.read(projectEslintPath, 'utf-8');
+                tree.write(projectEslintPath, content.replace(rootEslintConfig, rootEslintConfig.replace('.base.', '.')));
+            }
+            else {
+                migrateEslintFile(projectEslintPath, tree);
+            }
+        }
+    });
+}
+exports.migrateConfigToMonorepoStyle = migrateConfigToMonorepoStyle;
+function findLintTarget(project) {
+    return Object.values(project.targets ?? {}).find((target) => target.executor === '@nx/eslint:lint' ||
+        target.executor === '@nx/linter:eslint' ||
+        target.executor === '@nrwl/linter:eslint');
+}
+exports.findLintTarget = findLintTarget;
+function migrateEslintFile(projectEslintPath, tree) {
+    const baseFile = (0, eslint_file_1.findEslintFile)(tree);
+    if ((0, eslint_file_1.isEslintConfigSupported)(tree)) {
+        if ((0, flat_config_1.useFlatConfig)(tree)) {
+            let config = tree.read(projectEslintPath, 'utf-8');
+            // remove @nx plugin
+            config = (0, ast_utils_1.removePlugin)(config, '@nx', '@nx/eslint-plugin-nx');
+            // extend eslint.base.config.js
+            config = (0, ast_utils_1.addImportToFlatConfig)(config, 'baseConfig', `${(0, devkit_1.offsetFromRoot)((0, path_1.dirname)(projectEslintPath))}${baseFile}`);
+            config = (0, ast_utils_1.addBlockToFlatConfigExport)(config, (0, ast_utils_1.generateSpreadElement)('baseConfig'), { insertAtTheEnd: false });
+            // cleanup file extends
+            config = (0, ast_utils_1.removeCompatExtends)(config, [
+                'plugin:@nx/typescript',
+                'plugin:@nx/javascript',
+                'plugin:@nrwl/typescript',
+                'plugin:@nrwl/javascript',
+            ]);
+            tree.write(projectEslintPath, config);
+        }
+        else {
+            (0, devkit_1.updateJson)(tree, projectEslintPath, (json) => {
+                // we have a new root now
+                delete json.root;
+                // remove nrwl/nx plugins
+                if (json.plugins) {
+                    json.plugins = json.plugins.filter((p) => p !== '@nx' && p !== '@nrwl/nx');
+                    if (json.plugins.length === 0) {
+                        delete json.plugins;
+                    }
+                }
+                // add extends
+                json.extends = json.extends || [];
+                const pathToRootConfig = `${(0, devkit_1.offsetFromRoot)((0, path_1.dirname)(projectEslintPath))}${baseFile}`;
+                if (json.extends.indexOf(pathToRootConfig) === -1) {
+                    json.extends.push(pathToRootConfig);
+                }
+                // cleanup overrides
+                if (json.overrides) {
+                    json.overrides.forEach((override) => {
+                        if (override.extends) {
+                            override.extends = override.extends.filter((ext) => ext !== 'plugin:@nx/typescript' &&
+                                ext !== 'plugin:@nrwl/nx/typescript' &&
+                                ext !== 'plugin:@nx/javascript' &&
+                                ext !== 'plugin:@nrwl/nx/javascript');
+                            if (override.extends.length === 0) {
+                                delete override.extends;
+                            }
+                        }
+                    });
+                }
+                return json;
+            });
+        }
+        return;
+    }
+    if (projectEslintPath.endsWith('.yml') ||
+        projectEslintPath.endsWith('.yaml')) {
+        console.warn('YAML eslint config is not supported yet for migration');
+    }
+    if (projectEslintPath.endsWith('.js') || projectEslintPath.endsWith('.cjs')) {
+        console.warn('JS eslint config is not supported yet for migration');
+    }
+}

package/src/generators/init/init.d.ts

@@ -0,0 +1,9 @@
+import type { GeneratorCallback, Tree } from '@nx/devkit';
+export interface LinterInitOptions {
+    skipPackageJson?: boolean;
+    keepExistingVersions?: boolean;
+    updatePackageScripts?: boolean;
+    addPlugin?: boolean;
+}
+export declare function initEsLint(tree: Tree, options: LinterInitOptions): Promise<GeneratorCallback>;
+export declare function lintInitGenerator(tree: Tree, options: LinterInitOptions): Promise<GeneratorCallback>;

package/src/generators/init/init.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintInitGenerator = exports.initEsLint = void 0;
+const devkit_1 = require("@nx/devkit");
+const update_package_scripts_1 = require("@nx/devkit/src/utils/update-package-scripts");
+const versions_1 = require("../../utils/versions");
+const eslint_file_1 = require("../utils/eslint-file");
+const plugin_1 = require("../../plugins/plugin");
+const plugin_2 = require("../utils/plugin");
+function updateProductionFileset(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const productionFileSet = nxJson.namedInputs?.production;
+    if (productionFileSet) {
+        productionFileSet.push('!{projectRoot}/.eslintrc.json');
+        productionFileSet.push('!{projectRoot}/eslint.config.js');
+        // Dedupe and set
+        nxJson.namedInputs.production = Array.from(new Set(productionFileSet));
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+function addTargetDefaults(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.targetDefaults ??= {};
+    nxJson.targetDefaults['@nx/eslint:lint'] ??= {};
+    nxJson.targetDefaults['@nx/eslint:lint'].cache ??= true;
+    nxJson.targetDefaults['@nx/eslint:lint'].inputs ??= [
+        'default',
+        `{workspaceRoot}/.eslintrc.json`,
+        `{workspaceRoot}/.eslintignore`,
+        `{workspaceRoot}/eslint.config.js`,
+    ];
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.plugins ??= [];
+    for (const plugin of nxJson.plugins) {
+        if (typeof plugin === 'string'
+            ? plugin === '@nx/eslint/plugin'
+            : plugin.plugin === '@nx/eslint/plugin') {
+            return;
+        }
+    }
+    nxJson.plugins.push({
+        plugin: '@nx/eslint/plugin',
+        options: {
+            targetName: 'lint',
+        },
+    });
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+async function initEsLint(tree, options) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPluginDefault;
+    const hasPlugin = (0, plugin_2.hasEslintPlugin)(tree);
+    const rootEslintFile = (0, eslint_file_1.findEslintFile)(tree);
+    if (rootEslintFile && options.addPlugin && !hasPlugin) {
+        addPlugin(tree);
+        if (options.updatePackageScripts) {
+            await (0, update_package_scripts_1.updatePackageScripts)(tree, plugin_1.createNodes);
+        }
+        return () => { };
+    }
+    if (rootEslintFile) {
+        return () => { };
+    }
+    updateProductionFileset(tree);
+    if (options.addPlugin) {
+        addPlugin(tree);
+    }
+    else {
+        addTargetDefaults(tree);
+    }
+    const tasks = [];
+    if (!options.skipPackageJson) {
+        tasks.push((0, devkit_1.removeDependenciesFromPackageJson)(tree, ['@nx/eslint'], []));
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/eslint': versions_1.nxVersion,
+            eslint: versions_1.eslintVersion,
+        }, undefined, options.keepExistingVersions));
+    }
+    if (options.updatePackageScripts) {
+        await (0, update_package_scripts_1.updatePackageScripts)(tree, plugin_1.createNodes);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.initEsLint = initEsLint;
+async function lintInitGenerator(tree, options) {
+    return await initEsLint(tree, { addPlugin: false, ...options });
+}
+exports.lintInitGenerator = lintInitGenerator;

package/src/generators/init/schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxESLintInit",
+  "title": "Initialize ESLint Plugin",
+  "description": "Set up the ESLint plugin.",
+  "type": "object",
+  "properties": {
+    "skipPackageJson": {
+      "description": "Do not add dependencies to `package.json`.",
+      "type": "boolean",
+      "default": false
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    },
+    "updatePackageScripts": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Update `package.json` scripts with inferred targets",
+      "default": false
+    }
+  },
+  "required": []
+}

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

@@ -0,0 +1,22 @@
+import type { GeneratorCallback, 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;
+    keepExistingVersions?: boolean;
+    addPlugin?: boolean;
+    /**
+     * @internal
+     */
+    addExplicitTargets?: boolean;
+}
+export declare function lintProjectGenerator(tree: Tree, options: LintProjectOptions): Promise<GeneratorCallback>;
+export declare function lintProjectGeneratorInternal(tree: Tree, options: LintProjectOptions): Promise<GeneratorCallback>;
+export {};

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

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintProjectGeneratorInternal = exports.lintProjectGenerator = 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");
+const config_file_1 = require("../../utils/config-file");
+const plugin_1 = require("../utils/plugin");
+const setup_root_eslint_1 = require("./setup-root-eslint");
+function lintProjectGenerator(tree, options) {
+    return lintProjectGeneratorInternal(tree, { addPlugin: false, ...options });
+}
+exports.lintProjectGenerator = lintProjectGenerator;
+async function lintProjectGeneratorInternal(tree, options) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPluginDefault;
+    const tasks = [];
+    const initTask = await (0, init_1.lintInitGenerator)(tree, {
+        skipPackageJson: options.skipPackageJson,
+        addPlugin: options.addPlugin,
+    });
+    tasks.push(initTask);
+    const rootEsLintTask = (0, setup_root_eslint_1.setupRootEsLint)(tree, {
+        unitTestRunner: options.unitTestRunner,
+        skipPackageJson: options.skipPackageJson,
+        rootProject: options.rootProject,
+    });
+    tasks.push(rootEsLintTask);
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    let lintFilePatterns = options.eslintFilePatterns;
+    if (!lintFilePatterns && options.rootProject && projectConfig.root === '.') {
+        lintFilePatterns = ['./src'];
+    }
+    if (lintFilePatterns &&
+        lintFilePatterns.length &&
+        !lintFilePatterns.includes('{projectRoot}') &&
+        isBuildableLibraryProject(projectConfig)) {
+        lintFilePatterns.push(`{projectRoot}/package.json`);
+    }
+    const hasPlugin = (0, plugin_1.hasEslintPlugin)(tree);
+    if (hasPlugin && !options.addExplicitTargets) {
+        if (lintFilePatterns &&
+            lintFilePatterns.length &&
+            lintFilePatterns.some((p) => !['./src', '{projectRoot}', projectConfig.root].includes(p))) {
+            projectConfig.targets['lint'] = {
+                command: `eslint ${lintFilePatterns
+                    .join(' ')
+                    .replace('{projectRoot}', projectConfig.root)}`,
+            };
+        }
+    }
+    else {
+        projectConfig.targets['lint'] = {
+            executor: '@nx/eslint:lint',
+        };
+        if (lintFilePatterns && lintFilePatterns.length) {
+            // only add lintFilePatterns if they are explicitly defined
+            projectConfig.targets['lint'].options = {
+                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, options.keepExistingVersions);
+        }
+    }
+    // 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, options.rootProject);
+    }
+    // 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 (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.lintProjectGeneratorInternal = lintProjectGeneratorInternal;
+function createEsLintConfiguration(tree, projectConfig, setParserOptionsProject, rootProject) {
+    // we are only extending root for non-standalone projects or their complementary e2e apps
+    const extendedRootConfig = rootProject ? undefined : (0, eslint_file_1.findEslintFile)(tree);
+    const pathToRootConfig = extendedRootConfig
+        ? `${(0, devkit_1.offsetFromRoot)(projectConfig.root)}${extendedRootConfig}`
+        : 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 (extendedRootConfig) {
+            importMap.set(pathToRootConfig, 'baseConfig');
+            nodes.push((0, ast_utils_1.generateSpreadElement)('baseConfig'));
+        }
+        overrides.forEach((override) => {
+            nodes.push((0, ast_utils_1.generateFlatOverride)(override));
+        });
+        const nodeList = (0, ast_utils_1.createNodeList)(importMap, nodes, isCompatNeeded);
+        const content = (0, ast_utils_1.stringifyNodeList)(nodeList);
+        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: extendedRootConfig ? [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(config_file_1.baseEsLintConfigFile) ||
+        tree.exists(config_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;
+    }
+    // check if we're inferring lint target from `@nx/eslint/plugin`
+    if ((0, plugin_1.hasEslintPlugin)(tree)) {
+        for (const f of config_file_1.ESLINT_CONFIG_FILENAMES) {
+            if (tree.exists(f)) {
+                return true;
+            }
+        }
+    }
+    // find if root project has lint target
+    const lintTarget = (0, init_migration_1.findLintTarget)(rootProject);
+    return !!lintTarget;
+}

package/src/generators/lint-project/setup-root-eslint.d.ts

@@ -0,0 +1,7 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+export type SetupRootEsLintOptions = {
+    unitTestRunner?: string;
+    skipPackageJson?: boolean;
+    rootProject?: boolean;
+};
+export declare function setupRootEsLint(tree: Tree, options: SetupRootEsLintOptions): GeneratorCallback;

package/src/generators/lint-project/setup-root-eslint.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupRootEsLint = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../utils/versions");
+const global_eslint_config_1 = require("../init/global-eslint-config");
+const eslint_file_1 = require("../utils/eslint-file");
+function setupRootEsLint(tree, options) {
+    const rootEslintFile = (0, eslint_file_1.findEslintFile)(tree);
+    if (rootEslintFile) {
+        return () => { };
+    }
+    (0, devkit_1.writeJson)(tree, '.eslintrc.json', (0, global_eslint_config_1.getGlobalEsLintConfiguration)(options.unitTestRunner, options.rootProject));
+    if (tree.exists('.eslintignore')) {
+        let content = tree.read('.eslintignore', 'utf-8');
+        if (!/^node_modules$/gm.test(content)) {
+            content = `${content}\nnode_modules\n`;
+            tree.write('.eslintignore', content);
+        }
+    }
+    else {
+        tree.write('.eslintignore', 'node_modules\n');
+    }
+    return !options.skipPackageJson
+        ? (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/eslint-plugin': versions_1.nxVersion,
+            '@typescript-eslint/parser': versions_1.typescriptESLintVersion,
+            '@typescript-eslint/eslint-plugin': versions_1.typescriptESLintVersion,
+            'eslint-config-prettier': versions_1.eslintConfigPrettierVersion,
+        })
+        : () => { };
+}
+exports.setupRootEsLint = setupRootEsLint;