@nx/eslint 17.0.0-beta.8

package/src/executors/lint/utility/eslint-utils.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAndInstantiateESLint = void 0;
+async function resolveESLintClass(useFlatConfig = false) {
+    try {
+        if (!useFlatConfig) {
+            return (await Promise.resolve().then(() => require('eslint'))).ESLint;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { FlatESLint } = require('eslint/use-at-your-own-risk');
+        return FlatESLint;
+    }
+    catch {
+        throw new Error('Unable to find ESLint. Ensure ESLint is installed.');
+    }
+}
+async function resolveAndInstantiateESLint(eslintConfigPath, options, useFlatConfig = false) {
+    if (useFlatConfig &&
+        eslintConfigPath &&
+        !eslintConfigPath?.endsWith('eslint.config.js')) {
+        throw new Error('When using the new Flat Config with ESLint, all configs must be named eslint.config.js and .eslintrc files may not be used. See https://eslint.org/docs/latest/use/configure/configuration-files-new');
+    }
+    const ESLint = await resolveESLintClass(useFlatConfig);
+    const eslintOptions = {
+        overrideConfigFile: eslintConfigPath,
+        fix: !!options.fix,
+        cache: !!options.cache,
+        cacheLocation: options.cacheLocation || undefined,
+        cacheStrategy: options.cacheStrategy || undefined,
+        /**
+         * Default is `true` and if not overridden the eslint.lintFiles() method will throw an error
+         * when no target files are found.
+         *
+         * We don't want ESLint to throw an error if a user has only just created
+         * a project and therefore doesn't necessarily have matching files, for example.
+         *
+         * Also, the angular generator creates a lint pattern for `html` files, but there may
+         * not be any html files in the project, so keeping it true would break linting every time
+         */
+        errorOnUnmatchedPattern: false,
+        reportUnusedDisableDirectives: options.reportUnusedDisableDirectives || undefined,
+    };
+    if (useFlatConfig) {
+        if (typeof options.useEslintrc !== 'undefined') {
+            throw new Error('For Flat Config, the `useEslintrc` option is not applicable. See https://eslint.org/docs/latest/use/configure/configuration-files-new');
+        }
+        if (options.resolvePluginsRelativeTo !== undefined) {
+            throw new Error('For Flat Config, ESLint removed `resolvePluginsRelativeTo` and so it is not supported as an option. See https://eslint.org/docs/latest/use/configure/configuration-files-new');
+        }
+        if (options.ignorePath !== undefined) {
+            throw new Error('For Flat Config, ESLint removed `ignorePath` and so it is not supported as an option. See https://eslint.org/docs/latest/use/configure/configuration-files-new');
+        }
+    }
+    else {
+        eslintOptions.rulePaths = options.rulesdir || [];
+        eslintOptions.resolvePluginsRelativeTo =
+            options.resolvePluginsRelativeTo || undefined;
+        eslintOptions.ignorePath = options.ignorePath || undefined;
+        /**
+         * If "noEslintrc" is set to `true` (and therefore here "useEslintrc" will be `false`), then ESLint will not
+         * merge the provided config with others it finds automatically.
+         */
+        eslintOptions.useEslintrc = !options.noEslintrc;
+    }
+    const eslint = new ESLint(eslintOptions);
+    return {
+        ESLint,
+        eslint,
+    };
+}
+exports.resolveAndInstantiateESLint = resolveAndInstantiateESLint;

package/src/generators/convert-to-flat-config/converters/json-converter.d.ts

@@ -0,0 +1,6 @@
+import { Tree } from '@nx/devkit';
+/**
+ * Converts an ESLint JSON config to a flat config.
+ * Deletes the original file along with .eslintignore if it exists.
+ */
+export declare function convertEslintJsonToFlatConfig(tree: Tree, root: string, sourceFile: string, destinationFile: string): void;

package/src/generators/convert-to-flat-config/converters/json-converter.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertEslintJsonToFlatConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const ts = require("typescript");
+const versions_1 = require("../../../utils/versions");
+const ast_utils_1 = require("../../utils/flat-config/ast-utils");
+const eslint_file_1 = require("../../utils/eslint-file");
+/**
+ * Converts an ESLint JSON config to a flat config.
+ * Deletes the original file along with .eslintignore if it exists.
+ */
+function convertEslintJsonToFlatConfig(tree, root, sourceFile, destinationFile) {
+    const importsMap = new Map();
+    const exportElements = [];
+    let isFlatCompatNeeded = false;
+    let combinedConfig = [];
+    let languageOptions = [];
+    // read original config
+    const config = (0, devkit_1.readJson)(tree, `${root}/${sourceFile}`);
+    if (config.extends) {
+        isFlatCompatNeeded = addExtends(importsMap, exportElements, config, tree);
+    }
+    if (config.plugins) {
+        addPlugins(importsMap, exportElements, config);
+    }
+    if (config.parser) {
+        const imp = config.parser;
+        const parserName = (0, devkit_1.names)(imp).propertyName;
+        importsMap.set(imp, parserName);
+        languageOptions.push(ts.factory.createPropertyAssignment('parser', ts.factory.createIdentifier(parserName)));
+    }
+    if (config.parserOptions) {
+        languageOptions.push(ts.factory.createPropertyAssignment('parserOptions', (0, ast_utils_1.generateAst)(config.parserOptions)));
+    }
+    if (config.globals || config.env) {
+        if (config.env) {
+            importsMap.set('globals', 'globals');
+        }
+        languageOptions.push(ts.factory.createPropertyAssignment('globals', ts.factory.createObjectLiteralExpression([
+            ...Object.keys(config.env || {}).map((env) => ts.factory.createSpreadAssignment(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('globals'), ts.factory.createIdentifier(env)))),
+            ...Object.keys(config.globals || {}).map((key) => ts.factory.createPropertyAssignment(key, (0, ast_utils_1.generateAst)(config.globals[key]))),
+        ])));
+    }
+    if (config.settings) {
+        combinedConfig.push(ts.factory.createPropertyAssignment('settings', (0, ast_utils_1.generateAst)(config.settings)));
+    }
+    if (config.noInlineConfig !== undefined ||
+        config.reportUnusedDisableDirectives !== undefined) {
+        combinedConfig.push(ts.factory.createPropertyAssignment('linterOptions', (0, ast_utils_1.generateAst)({
+            noInlineConfig: config.noInlineConfig,
+            reportUnusedDisableDirectives: config.reportUnusedDisableDirectives,
+        })));
+    }
+    if (languageOptions.length > 0) {
+        combinedConfig.push(ts.factory.createPropertyAssignment('languageOptions', ts.factory.createObjectLiteralExpression(languageOptions, languageOptions.length > 1)));
+    }
+    if (combinedConfig.length > 0) {
+        exportElements.push(ts.factory.createObjectLiteralExpression(combinedConfig, combinedConfig.length > 1));
+    }
+    if (config.rules) {
+        exportElements.push((0, ast_utils_1.generateAst)({ rules: config.rules }));
+    }
+    if (config.overrides) {
+        config.overrides.forEach((override) => {
+            if (override.env ||
+                override.extends ||
+                override.plugins ||
+                override.parser) {
+                isFlatCompatNeeded = true;
+            }
+            exportElements.push((0, ast_utils_1.generateFlatOverride)(override, root));
+        });
+    }
+    if (config.ignorePatterns) {
+        const patterns = (Array.isArray(config.ignorePatterns)
+            ? config.ignorePatterns
+            : [config.ignorePatterns]).filter((pattern) => !['**/*', '!**/*', 'node_modules'].includes(pattern)); // these are useless in a flat config
+        if (patterns.length > 0) {
+            exportElements.push((0, ast_utils_1.generateAst)({
+                ignores: patterns.map((path) => (0, ast_utils_1.mapFilePath)(path, root)),
+            }));
+        }
+    }
+    if (tree.exists(`${root}/.eslintignore`)) {
+        const patterns = tree
+            .read(`${root}/.eslintignore`, 'utf-8')
+            .split('\n')
+            .filter((line) => line.length > 0 && line !== 'node_modules')
+            .map((path) => (0, ast_utils_1.mapFilePath)(path, root));
+        if (patterns.length > 0) {
+            exportElements.push((0, ast_utils_1.generateAst)({ ignores: patterns }));
+        }
+    }
+    tree.delete((0, path_1.join)(root, sourceFile));
+    tree.delete((0, path_1.join)(root, '.eslintignore'));
+    // create the node list and print it to new file
+    const nodeList = (0, ast_utils_1.createNodeList)(importsMap, exportElements, isFlatCompatNeeded);
+    const content = (0, ast_utils_1.stringifyNodeList)(nodeList, root, destinationFile);
+    tree.write((0, path_1.join)(root, destinationFile), content);
+    if (isFlatCompatNeeded) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@eslint/eslintrc': versions_1.eslintrcVersion,
+        });
+    }
+}
+exports.convertEslintJsonToFlatConfig = convertEslintJsonToFlatConfig;
+// add parsed extends to export blocks and add import statements
+function addExtends(importsMap, configBlocks, config, tree) {
+    let isFlatCompatNeeded = false;
+    const extendsConfig = Array.isArray(config.extends)
+        ? config.extends
+        : [config.extends];
+    const eslintrcConfigs = [];
+    // add base extends
+    extendsConfig
+        .filter((imp) => imp.match(/^\.?(\.\/)/))
+        .forEach((imp, index) => {
+        if (imp.match(/\.eslintrc(.base)?\.json$/)) {
+            const localName = index ? `baseConfig${index}` : 'baseConfig';
+            configBlocks.push((0, ast_utils_1.generateSpreadElement)(localName));
+            const newImport = imp.replace(/^(.*)\.eslintrc(.base)?\.json$/, '$1eslint$2.config.js');
+            importsMap.set(newImport, localName);
+        }
+        else {
+            eslintrcConfigs.push(imp);
+        }
+    });
+    // add plugin extends
+    const pluginExtends = extendsConfig.filter((imp) => !imp.match(/^\.?(\.\/)/));
+    if (pluginExtends.length) {
+        const eslintPluginExtends = pluginExtends.filter((imp) => imp.startsWith('eslint:'));
+        pluginExtends.forEach((imp) => {
+            if (!imp.startsWith('eslint:')) {
+                eslintrcConfigs.push(imp);
+            }
+        });
+        if (eslintPluginExtends.length) {
+            (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+                '@eslint/js': versions_1.eslintVersion,
+            });
+            importsMap.set('@eslint/js', 'js');
+            eslintPluginExtends.forEach((plugin) => {
+                configBlocks.push(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('js'), ts.factory.createIdentifier('configs')), ts.factory.createIdentifier(plugin.slice(7)) // strip 'eslint:' prefix
+                ));
+            });
+        }
+    }
+    if (eslintrcConfigs.length) {
+        isFlatCompatNeeded = true;
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@eslint/js': versions_1.eslintVersion,
+        });
+        configBlocks.push((0, ast_utils_1.generatePluginExtendsElement)(eslintrcConfigs));
+    }
+    return isFlatCompatNeeded;
+}
+function addPlugins(importsMap, configBlocks, config) {
+    const mappedPlugins = [];
+    config.plugins.forEach((name) => {
+        const imp = (0, eslint_file_1.getPluginImport)(name);
+        const varName = (0, devkit_1.names)(imp).propertyName;
+        mappedPlugins.push({ name, varName, imp });
+    });
+    mappedPlugins.forEach(({ varName, imp }) => {
+        importsMap.set(imp, varName);
+    });
+    const pluginsAst = ts.factory.createObjectLiteralExpression([
+        ts.factory.createPropertyAssignment('plugins', ts.factory.createObjectLiteralExpression(mappedPlugins.map(({ name, varName }) => {
+            return ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(name), ts.factory.createIdentifier(varName));
+        }), mappedPlugins.length > 1)),
+        ...(config.processor
+            ? [
+                ts.factory.createPropertyAssignment('processor', ts.factory.createStringLiteral(config.processor)),
+            ]
+            : []),
+    ], false);
+    configBlocks.push(pluginsAst);
+}

package/src/generators/convert-to-flat-config/generator.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+import { ConvertToFlatConfigGeneratorSchema } from './schema';
+export declare function convertToFlatConfigGenerator(tree: Tree, options: ConvertToFlatConfigGeneratorSchema): Promise<void>;
+export default convertToFlatConfigGenerator;

package/src/generators/convert-to-flat-config/generator.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToFlatConfigGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const eslint_file_1 = require("../utils/eslint-file");
+const json_converter_1 = require("./converters/json-converter");
+async function convertToFlatConfigGenerator(tree, options) {
+    const eslintFile = (0, eslint_file_1.findEslintFile)(tree);
+    if (!eslintFile) {
+        throw new Error('Could not find root eslint file');
+    }
+    if (!eslintFile.endsWith('.json')) {
+        throw new Error('Only json eslint config files are supported for conversion');
+    }
+    // rename root eslint config to eslint.config.js
+    convertRootToFlatConfig(tree, eslintFile);
+    // rename and map files
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const [project, projectConfig] of projects) {
+        convertProjectToFlatConfig(tree, project, projectConfig, (0, devkit_1.readNxJson)(tree));
+    }
+    // replace references in nx.json
+    updateNxJsonConfig(tree);
+    // install missing packages
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.convertToFlatConfigGenerator = convertToFlatConfigGenerator;
+exports.default = convertToFlatConfigGenerator;
+function convertRootToFlatConfig(tree, eslintFile) {
+    if (eslintFile.endsWith('.base.json')) {
+        convertConfigToFlatConfig(tree, '', '.eslintrc.base.json', 'eslint.base.config.js');
+    }
+    convertConfigToFlatConfig(tree, '', '.eslintrc.json', 'eslint.config.js');
+}
+function convertProjectToFlatConfig(tree, project, projectConfig, nxJson) {
+    if (tree.exists(`${projectConfig.root}/.eslintrc.json`)) {
+        if (projectConfig.targets) {
+            const eslintTargets = Object.keys(projectConfig.targets || {}).filter((t) => projectConfig.targets[t].executor === '@nx/eslint:lint');
+            for (const target of eslintTargets) {
+                // remove any obsolete `eslintConfig` options pointing to the old config file
+                if (projectConfig.targets[target].options?.eslintConfig) {
+                    delete projectConfig.targets[target].options.eslintConfig;
+                }
+                (0, devkit_1.updateProjectConfiguration)(tree, project, projectConfig);
+            }
+            const nxHasLintTargets = Object.keys(nxJson.targetDefaults || {}).some((t) => (t === '@nx/eslint:lint' ||
+                nxJson.targetDefaults[t].executor === '@nx/eslint:lint') &&
+                projectConfig.targets?.[t]);
+            if (nxHasLintTargets || eslintTargets.length > 0) {
+                convertConfigToFlatConfig(tree, projectConfig.root, '.eslintrc.json', 'eslint.config.js');
+            }
+        }
+    }
+}
+// update names of eslint files in nx.json
+// and remove eslintignore
+function updateNxJsonConfig(tree) {
+    if (tree.exists('nx.json')) {
+        (0, devkit_1.updateJson)(tree, 'nx.json', (json) => {
+            if (json.targetDefaults?.lint?.inputs) {
+                const inputSet = new Set(json.targetDefaults.lint.inputs);
+                inputSet.add('{workspaceRoot}/eslint.config.js');
+                json.targetDefaults.lint.inputs = Array.from(inputSet);
+            }
+            if (json.targetDefaults?.['@nx/eslint:lint']?.inputs) {
+                const inputSet = new Set(json.targetDefaults['@nx/eslint:lint'].inputs);
+                inputSet.add('{workspaceRoot}/eslint.config.js');
+                json.targetDefaults['@nx/eslint:lint'].inputs = Array.from(inputSet);
+            }
+            if (json.namedInputs?.production) {
+                const inputSet = new Set(json.namedInputs.production);
+                inputSet.add('!{projectRoot}/eslint.config.js');
+                json.namedInputs.production = Array.from(inputSet);
+            }
+            return json;
+        });
+    }
+}
+function convertConfigToFlatConfig(tree, root, source, target) {
+    (0, json_converter_1.convertEslintJsonToFlatConfig)(tree, root, source, target);
+}

package/src/generators/convert-to-flat-config/schema.d.ts

@@ -0,0 +1,3 @@
+export interface ConvertToFlatConfigGeneratorSchema {
+  skipFormat?: boolean;
+}

package/src/generators/convert-to-flat-config/schema.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "ConvertToFlatConfig",
+  "cli": "nx",
+  "description": "Convert an Nx workspace's ESLint configs to use Flat Config.",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files.",
+      "default": false,
+      "x-priority": "internal"
+    }
+  },
+  "additionalProperties": false,
+  "required": []
+}

package/src/generators/init/global-eslint-config.d.ts

@@ -0,0 +1,29 @@
+import { Linter } from 'eslint';
+/**
+ * This configuration is intended to apply to all TypeScript source files.
+ * See the eslint-plugin package for what is in the referenced shareable config.
+ */
+export declare const typeScriptOverride: {
+    files: string[];
+    extends: string[];
+    /**
+     * 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.
+ */
+export declare const javaScriptOverride: {
+    files: string[];
+    extends: string[];
+    /**
+     * Having an empty rules object present makes it more obvious to the user where they would
+     * extend things from if they needed to
+     */
+    rules: {};
+};
+export declare const getGlobalEsLintConfiguration: (unitTestRunner?: string, rootProject?: boolean) => Linter.Config;
+export declare const getGlobalFlatEslintConfiguration: (unitTestRunner?: string, rootProject?: boolean) => string;

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

@@ -0,0 +1,98 @@
+"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, '', 'eslint.config.js');
+    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, ''));
+    }
+    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): void;
+export declare function findLintTarget(project: ProjectConfiguration): TargetConfiguration;

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

@@ -0,0 +1,103 @@
+"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");
+function migrateConfigToMonorepoStyle(projects, tree, unitTestRunner) {
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        // we need this for the compat
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@eslint/js': versions_1.eslintVersion,
+        });
+        tree.write('eslint.base.config.js', (0, global_eslint_config_1.getGlobalFlatEslintConfiguration)(unitTestRunner));
+    }
+    else {
+        (0, devkit_1.writeJson)(tree, '.eslintrc.base.json', (0, global_eslint_config_1.getGlobalEsLintConfiguration)(unitTestRunner));
+    }
+    // update extens in all projects' eslint configs
+    projects.forEach((project) => {
+        const lintTarget = findLintTarget(project);
+        if (lintTarget) {
+            const eslintFile = lintTarget.options.eslintConfig || (0, eslint_file_1.findEslintFile)(tree, project.root);
+            if (eslintFile) {
+                const projectEslintPath = (0, devkit_1.joinPathFragments)(project.root, eslintFile);
+                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) {
+    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))}eslint.base.config.js`);
+            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',
+            ]);
+            console.warn('Flat eslint config is not supported yet for migration');
+            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))}.eslintrc.base.json`;
+                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';
+import { Linter } from '../utils/linter';
+export interface LinterInitOptions {
+    linter?: Linter;
+    unitTestRunner?: string;
+    skipPackageJson?: boolean;
+    rootProject?: boolean;
+}
+export declare function lintInitGenerator(tree: Tree, options: LinterInitOptions): GeneratorCallback;