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

package/src/executors/lint/schema.json

@@ -0,0 +1,148 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "$schema": "https://json-schema.org/schema",
+  "title": "ESLint Lint Target",
+  "description": "ESLint Lint Target.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "eslintConfig": {
+      "type": "string",
+      "description": "The name of the ESLint configuration file.",
+      "x-completion-type": "file",
+      "x-completion-glob": ".eslintrc?(.json)",
+      "x-priority": "important"
+    },
+    "lintFilePatterns": {
+      "type": "array",
+      "description": "One or more files/dirs/globs to pass directly to ESLint's `lintFiles()` method.",
+      "default": ["{projectRoot}"],
+      "items": {
+        "type": "string"
+      }
+    },
+    "format": {
+      "type": "string",
+      "description": "ESLint Output formatter (https://eslint.org/docs/user-guide/formatters).",
+      "default": "stylish",
+      "anyOf": [
+        {
+          "enum": [
+            "stylish",
+            "compact",
+            "codeframe",
+            "unix",
+            "visualstudio",
+            "table",
+            "checkstyle",
+            "html",
+            "jslint-xml",
+            "json",
+            "json-with-metadata",
+            "junit",
+            "tap"
+          ]
+        },
+        {
+          "minLength": 1
+        }
+      ],
+      "x-priority": "important"
+    },
+    "force": {
+      "type": "boolean",
+      "description": "Succeeds even if there was linting errors.",
+      "default": false
+    },
+    "silent": {
+      "type": "boolean",
+      "description": "Hide output text.",
+      "default": false
+    },
+    "fix": {
+      "type": "boolean",
+      "description": "Fixes linting errors (may overwrite linted files).",
+      "default": false,
+      "x-priority": "important"
+    },
+    "cache": {
+      "type": "boolean",
+      "description": "Only check changed files.",
+      "default": false
+    },
+    "cacheLocation": {
+      "type": "string",
+      "description": "Path to the cache file or directory.",
+      "x-completion-type": "directory",
+      "x-completion-glob": "tsconfig.*.json"
+    },
+    "outputFile": {
+      "type": "string",
+      "description": "File to write report to.",
+      "x-completion-type": "file"
+    },
+    "maxWarnings": {
+      "type": "number",
+      "description": "Number of warnings to trigger nonzero exit code - default: `-1`.",
+      "default": -1
+    },
+    "quiet": {
+      "type": "boolean",
+      "description": "Report errors only - default: `false`.",
+      "default": false,
+      "x-priority": "important"
+    },
+    "ignorePath": {
+      "type": "string",
+      "description": "The path of the `.eslintignore` file. Not supported for Flat Config.",
+      "x-completion-type": "file",
+      "x-completion-glob": ".eslintignore"
+    },
+    "noEslintrc": {
+      "type": "boolean",
+      "description": "The equivalent of the `--no-eslintrc` flag on the ESLint CLI, it is `false` by default.",
+      "default": false
+    },
+    "hasTypeAwareRules": {
+      "type": "boolean",
+      "description": "When set to `true`, the linter will invalidate its cache when any of its dependencies changes."
+    },
+    "cacheStrategy": {
+      "type": "string",
+      "description": "Strategy to use for detecting changed files in the cache.",
+      "default": "metadata",
+      "enum": ["metadata", "content"]
+    },
+    "rulesdir": {
+      "type": "array",
+      "description": "The equivalent of the `--rulesdir` flag on the ESLint CLI.",
+      "default": [],
+      "items": {
+        "type": "string",
+        "x-completion-type": "directory"
+      }
+    },
+    "resolvePluginsRelativeTo": {
+      "type": "string",
+      "description": "The equivalent of the `--resolve-plugins-relative-to` flag on the ESLint CLI. Not supported for Flat Config.",
+      "x-completion-type": "directory"
+    },
+    "reportUnusedDisableDirectives": {
+      "type": "string",
+      "enum": ["off", "warn", "error"],
+      "description": "The equivalent of the `--report-unused-disable-directives` flag on the ESLint CLI."
+    },
+    "printConfig": {
+      "type": "string",
+      "description": "The equivalent of the `--print-config` flag on the ESLint CLI.",
+      "x-completion-type": "file"
+    },
+    "errorOnUnmatchedPattern": {
+      "type": "boolean",
+      "description": "When set to false, equivalent of the `--no-error-on-unmatched-pattern` flag on the ESLint CLI.",
+      "default": true
+    }
+  },
+  "examplesFile": "../../../docs/eslint-examples.md"
+}

package/src/executors/lint/utility/eslint-utils.d.ts

@@ -0,0 +1,6 @@
+import type { ESLint } from 'eslint';
+import type { Schema } from '../schema';
+export declare function resolveAndInstantiateESLint(eslintConfigPath: string | undefined, options: Schema, useFlatConfig?: boolean): Promise<{
+    ESLint: typeof import("eslint").ESLint;
+    eslint: ESLint;
+}>;

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

@@ -0,0 +1,75 @@
+"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,
+    };
+    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');
+        }
+        if (options.reportUnusedDisableDirectives) {
+            throw new Error('For Flat Config, ESLint removed `reportedUnusedDisableDirectives` 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;
+        eslintOptions.reportUnusedDisableDirectives =
+            options.reportUnusedDisableDirectives || undefined;
+    }
+    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,11 @@
+import { Tree } from '@nx/devkit';
+import { ESLint } from 'eslint';
+/**
+ * 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, config: ESLint.ConfigData, ignorePaths: string[]): {
+    content: string;
+    addESLintRC: boolean;
+    addESLintJS: boolean;
+};

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

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertEslintJsonToFlatConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const ts = require("typescript");
+const ast_utils_1 = require("../../utils/flat-config/ast-utils");
+const eslint_file_1 = require("../../utils/eslint-file");
+const path_utils_1 = require("../../utils/flat-config/path-utils");
+/**
+ * Converts an ESLint JSON config to a flat config.
+ * Deletes the original file along with .eslintignore if it exists.
+ */
+function convertEslintJsonToFlatConfig(tree, root, config, ignorePaths) {
+    const importsMap = new Map();
+    const exportElements = [];
+    let isFlatCompatNeeded = false;
+    let isESLintJSNeeded = false;
+    let combinedConfig = [];
+    let languageOptions = [];
+    if (config.extends) {
+        const extendsResult = addExtends(importsMap, exportElements, config);
+        isFlatCompatNeeded = extendsResult.isFlatCompatNeeded;
+        isESLintJSNeeded = extendsResult.isESLintJSNeeded;
+    }
+    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));
+        });
+    }
+    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, path_utils_1.mapFilePath)(path)),
+            }));
+        }
+    }
+    for (const ignorePath of ignorePaths) {
+        if (tree.exists(ignorePath)) {
+            const patterns = tree
+                .read(ignorePath, 'utf-8')
+                .split('\n')
+                .filter((line) => line.length > 0 && line !== 'node_modules')
+                .map((path) => (0, path_utils_1.mapFilePath)(path));
+            if (patterns.length > 0) {
+                exportElements.push((0, ast_utils_1.generateAst)({ ignores: patterns }));
+            }
+        }
+    }
+    // create the node list and print it to new file
+    const nodeList = (0, ast_utils_1.createNodeList)(importsMap, exportElements, isFlatCompatNeeded);
+    return {
+        content: (0, ast_utils_1.stringifyNodeList)(nodeList),
+        addESLintRC: isFlatCompatNeeded,
+        addESLintJS: isESLintJSNeeded,
+    };
+}
+exports.convertEslintJsonToFlatConfig = convertEslintJsonToFlatConfig;
+// add parsed extends to export blocks and add import statements
+function addExtends(importsMap, configBlocks, config) {
+    let isFlatCompatNeeded = false;
+    let isESLintJSNeeded = 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) {
+            isESLintJSNeeded = true;
+            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;
+        isESLintJSNeeded = true;
+        configBlocks.push((0, ast_utils_1.generatePluginExtendsElement)(eslintrcConfigs));
+    }
+    return { isFlatCompatNeeded, isESLintJSNeeded };
+}
+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,139 @@
+"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 path_1 = require("path");
+const versions_1 = require("../../utils/versions");
+const json_converter_1 = require("./converters/json-converter");
+const js_yaml_1 = require("js-yaml");
+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('.js')) {
+        throw new Error('Only json and yaml eslint config files are supported for conversion');
+    }
+    const eslintIgnoreFiles = new Set(['.eslintignore']);
+    // convert root eslint config to eslint.config.js
+    convertRootToFlatConfig(tree, eslintFile);
+    // convert project eslint files to eslint.config.js
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const [project, projectConfig] of projects) {
+        convertProjectToFlatConfig(tree, project, projectConfig, (0, devkit_1.readNxJson)(tree), eslintIgnoreFiles);
+    }
+    // delete all .eslintignore files
+    for (const ignoreFile of eslintIgnoreFiles) {
+        tree.delete(ignoreFile);
+    }
+    // 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 (/\.base\.(js|json|yml|yaml)$/.test(eslintFile)) {
+        convertConfigToFlatConfig(tree, '', eslintFile, 'eslint.base.config.js');
+    }
+    convertConfigToFlatConfig(tree, '', eslintFile.replace('.base.', '.'), 'eslint.config.js');
+}
+function convertProjectToFlatConfig(tree, project, projectConfig, nxJson, eslintIgnoreFiles) {
+    const eslintFile = (0, eslint_file_1.findEslintFile)(tree, projectConfig.root);
+    if (eslintFile && !eslintFile.endsWith('.js')) {
+        if (projectConfig.targets) {
+            const eslintTargets = Object.keys(projectConfig.targets || {}).filter((t) => projectConfig.targets[t].executor === '@nx/eslint:lint' ||
+                projectConfig.targets[t].command?.includes('eslint'));
+            let ignorePath;
+            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;
+                }
+                if (projectConfig.targets[target].options?.ignorePath) {
+                    ignorePath = projectConfig.targets[target].options.ignorePath;
+                    delete projectConfig.targets[target].options.ignorePath;
+                }
+                (0, devkit_1.updateProjectConfiguration)(tree, project, projectConfig);
+            }
+            const nxHasEsLintTargets = Object.keys(nxJson.targetDefaults || {}).some((t) => (t === '@nx/eslint:lint' ||
+                nxJson.targetDefaults[t].executor === '@nx/eslint:lint' ||
+                nxJson.targetDefaults[t].command?.includes('eslint')) &&
+                projectConfig.targets?.[t]);
+            const nxHasEsLintPlugin = (nxJson.plugins || []).some((p) => typeof p === 'string'
+                ? p === '@nx/eslint/plugin'
+                : p.plugin === '@nx/eslint/plugin');
+            if (nxHasEsLintTargets || nxHasEsLintPlugin || eslintTargets.length > 0) {
+                convertConfigToFlatConfig(tree, projectConfig.root, eslintFile, 'eslint.config.js', ignorePath);
+                eslintIgnoreFiles.add(`${projectConfig.root}/.eslintignore`);
+                if (ignorePath) {
+                    eslintIgnoreFiles.add(ignorePath);
+                }
+            }
+        }
+    }
+}
+// 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, ignorePath) {
+    const ignorePaths = ignorePath
+        ? [ignorePath, `${root}/.eslintignore`]
+        : [`${root}/.eslintignore`];
+    if (source.endsWith('.json')) {
+        const config = (0, devkit_1.readJson)(tree, `${root}/${source}`);
+        const conversionResult = (0, json_converter_1.convertEslintJsonToFlatConfig)(tree, root, config, ignorePaths);
+        return processConvertedConfig(tree, root, source, target, conversionResult);
+    }
+    if (source.endsWith('.yaml') || source.endsWith('.yml')) {
+        const originalContent = tree.read(`${root}/${source}`, 'utf-8');
+        const config = (0, js_yaml_1.load)(originalContent, {
+            json: true,
+            filename: source,
+        });
+        const conversionResult = (0, json_converter_1.convertEslintJsonToFlatConfig)(tree, root, config, ignorePaths);
+        return processConvertedConfig(tree, root, source, target, conversionResult);
+    }
+}
+function processConvertedConfig(tree, root, source, target, { content, addESLintRC, addESLintJS, }) {
+    // remove original config file
+    tree.delete((0, path_1.join)(root, source));
+    // save new
+    tree.write((0, path_1.join)(root, target), content);
+    // add missing packages
+    if (addESLintRC) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@eslint/eslintrc': versions_1.eslintrcVersion,
+        });
+    }
+    if (addESLintJS) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@eslint/js': versions_1.eslintVersion,
+        });
+    }
+}

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": "https://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;