@nx/eslint 17.0.3 → 17.0.5

package/src/generators/workspace-rule/schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema",
+  "$schema": "https://json-schema.org/schema",
   "$id": "NxWorkspaceRule",
   "cli": "nx",
   "title": "Create a new Workspace Lint Rule",

package/src/generators/workspace-rule/workspace-rule.js

@@ -8,8 +8,13 @@ const ts = require("typescript");
 const workspace_lint_rules_1 = require("../../utils/workspace-lint-rules");
 const workspace_rules_project_1 = require("../workspace-rules-project/workspace-rules-project");
 async function lintWorkspaceRuleGenerator(tree, options) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
     // Ensure that the workspace rules project has been created
-    const projectGeneratorCallback = await (0, workspace_rules_project_1.lintWorkspaceRulesProjectGenerator)(tree, { skipFormat: true });
+    const projectGeneratorCallback = await (0, workspace_rules_project_1.lintWorkspaceRulesProjectGenerator)(tree, {
+        skipFormat: true,
+        addPlugin: process.env.NX_ADD_PLUGINS !== 'false' &&
+            nxJson.useInferencePlugins !== false,
+    });
     const ruleDir = (0, devkit_1.joinPathFragments)(workspace_lint_rules_1.workspaceLintPluginDir, options.directory ?? '');
     // Generate the required files for the new rule
     (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, 'files'), ruleDir, {
@@ -65,7 +70,7 @@ async function lintWorkspaceRuleGenerator(tree, options) {
     devkit_1.logger.info(`NX Reminder: Once you have finished writing your rule logic, you need to actually enable the rule within an appropriate ESLint config in your workspace, for example:
 
        "rules": {
-         "@nx/workspace/${options.name}": "error"
+         "@nx/workspace-${options.name}": "error"
        }
 `);
     return projectGeneratorCallback;

package/src/generators/workspace-rules-project/files/tsconfig.json__tmpl__

@@ -1,7 +1,8 @@
 {
   "extends": "<%= rootTsConfigPath %>",
   "compilerOptions": {
-    "module": "commonjs"
+    "moduleResolution": "node16",
+    "module": "node16"
   },
   "files": [],
   "include": [],

package/src/generators/workspace-rules-project/schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema",
+  "$schema": "https://json-schema.org/schema",
   "$id": "NxWorkspaceRulesProject",
   "cli": "nx",
   "title": "Create the Workspace Lint Rules Project",

package/src/generators/workspace-rules-project/workspace-rules-project.d.ts

@@ -1,7 +1,8 @@
-import { Tree } from '@nx/devkit';
+import { GeneratorCallback, Tree } from '@nx/devkit';
 export declare const WORKSPACE_RULES_PROJECT_NAME = "eslint-rules";
 export declare const WORKSPACE_PLUGIN_DIR = "tools/eslint-rules";
 export interface LintWorkspaceRulesProjectGeneratorOptions {
     skipFormat?: boolean;
+    addPlugin?: boolean;
 }
-export declare function lintWorkspaceRulesProjectGenerator(tree: Tree, options?: LintWorkspaceRulesProjectGeneratorOptions): Promise<import("@nx/devkit").GeneratorCallback>;
+export declare function lintWorkspaceRulesProjectGenerator(tree: Tree, options?: LintWorkspaceRulesProjectGeneratorOptions): Promise<GeneratorCallback>;

package/src/generators/workspace-rules-project/workspace-rules-project.js

@@ -10,7 +10,8 @@ const workspace_lint_rules_1 = require("../../utils/workspace-lint-rules");
 exports.WORKSPACE_RULES_PROJECT_NAME = 'eslint-rules';
 exports.WORKSPACE_PLUGIN_DIR = 'tools/eslint-rules';
 async function lintWorkspaceRulesProjectGenerator(tree, options = {}) {
-    const { addPropertyToJestConfig, configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
+    const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
+    const tasks = [];
     // Noop if the workspace rules project already exists
     try {
         (0, devkit_1.readProjectConfiguration)(tree, exports.WORKSPACE_RULES_PROJECT_NAME);
@@ -39,15 +40,17 @@ async function lintWorkspaceRulesProjectGenerator(tree, options = {}) {
         (0, devkit_1.updateNxJson)(tree, nxJson);
     }
     // Add jest to the project and return installation task
-    const installTask = await configurationGenerator(tree, {
+    tasks.push(await configurationGenerator(tree, {
+        ...options,
         project: exports.WORKSPACE_RULES_PROJECT_NAME,
         supportTsx: false,
         skipSerializers: true,
         setupFile: 'none',
         compiler: 'tsc',
         skipFormat: true,
-    });
+    }));
     (0, devkit_1.updateJson)(tree, (0, path_1.join)(workspace_lint_rules_1.workspaceLintPluginDir, 'tsconfig.spec.json'), (json) => {
+        delete json.compilerOptions?.module;
         if (json.include) {
             json.include = json.include.map((v) => {
                 if (v.startsWith('src/**')) {
@@ -67,14 +70,13 @@ async function lintWorkspaceRulesProjectGenerator(tree, options = {}) {
         return json;
     });
     // Add swc dependencies
-    (0, add_swc_dependencies_1.addSwcRegisterDependencies)(tree);
-    // Add extra config to the jest.config.ts file to allow ESLint 8 exports mapping to work with jest
-    addPropertyToJestConfig(tree, (0, devkit_1.joinPathFragments)(exports.WORKSPACE_PLUGIN_DIR, 'jest.config.ts'), 'moduleNameMapper', {
-        '@eslint/eslintrc': '@eslint/eslintrc/dist/eslintrc-universal.cjs',
-    });
+    tasks.push((0, add_swc_dependencies_1.addSwcRegisterDependencies)(tree));
+    tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        '@typescript-eslint/utils': versions_1.typescriptESLintVersion,
+    }));
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
-    return installTask;
+    return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 exports.lintWorkspaceRulesProjectGenerator = lintWorkspaceRulesProjectGenerator;

package/src/migrations/update-15-0-0/add-eslint-inputs.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const devkit_1 = require("@nx/devkit");
-const eslint_file_1 = require("../../generators/utils/eslint-file");
 const eslint_targets_1 = require("../../generators/utils/eslint-targets");
+const config_file_1 = require("../../utils/config-file");
 async function addEslintInputs(tree) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
-    const globalEslintFile = eslint_file_1.eslintConfigFileWhitelist.find((file) => tree.exists(file));
+    const globalEslintFile = config_file_1.ESLINT_CONFIG_FILENAMES.find((file) => tree.exists(file));
     if (globalEslintFile && nxJson.namedInputs?.production) {
         const productionFileset = new Set(nxJson.namedInputs.production);
         productionFileset.add(`!{projectRoot}/${globalEslintFile}`);

package/src/migrations/update-15-7-1/add-eslint-ignore.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const devkit_1 = require("@nx/devkit");
-const eslint_file_1 = require("../../generators/utils/eslint-file");
 const eslint_targets_1 = require("../../generators/utils/eslint-targets");
+const config_file_1 = require("../../utils/config-file");
 async function addEslintIgnore(tree) {
     const nxJson = (0, devkit_1.readJson)(tree, 'nx.json');
-    const globalEslintFile = eslint_file_1.eslintConfigFileWhitelist.find((file) => tree.exists(file));
+    const globalEslintFile = config_file_1.ESLINT_CONFIG_FILENAMES.find((file) => tree.exists(file));
     if (globalEslintFile) {
         if (tree.exists('.eslintignore')) {
             const content = tree.read('.eslintignore', 'utf-8');

package/src/migrations/update-17-1-0/update-typescript-eslint.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;

package/src/migrations/update-17-1-0/update-typescript-eslint.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../utils/versions");
+const path_1 = require("path");
+const typescript_1 = require("typescript");
+function updateJestConfig(tree) {
+    const jestConfigPath = 'tools/eslint-rules/jest.config.ts';
+    if (tree.exists(jestConfigPath)) {
+        const { removePropertyFromJestConfig } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
+        removePropertyFromJestConfig(tree, jestConfigPath, [
+            'moduleNameMapper',
+            '@eslint/eslintrc',
+        ]);
+    }
+}
+function updateTsConfigs(tree) {
+    const tsConfigPath = 'tools/eslint-rules/tsconfig.json';
+    if (tree.exists(tsConfigPath)) {
+        (0, devkit_1.updateJson)(tree, tsConfigPath, (tsConfig) => {
+            tsConfig.compilerOptions ??= {};
+            tsConfig.compilerOptions.moduleResolution = 'node16';
+            tsConfig.compilerOptions.module = 'node16';
+            return tsConfig;
+        });
+    }
+    const tsConfigSpec = 'tools/eslint-rules/tsconfig.spec.json';
+    if (tree.exists(tsConfigSpec)) {
+        (0, devkit_1.updateJson)(tree, tsConfigSpec, (tsConfigSpec) => {
+            delete tsConfigSpec.compilerOptions?.module;
+            delete tsConfigSpec.compilerOptions?.moduleResolution;
+            return tsConfigSpec;
+        });
+    }
+}
+function updateRecommended(tree) {
+    (0, devkit_1.visitNotIgnoredFiles)(tree, 'tools/eslint-rules', (path) => {
+        if ((0, path_1.extname)(path) !== '.ts') {
+            return;
+        }
+        const contents = tree.read(path, 'utf-8');
+        const sourceFile = (0, typescript_1.createSourceFile)(path, contents, typescript_1.ScriptTarget.ESNext, true);
+        const changes = [];
+        const visit = (node) => {
+            if ((0, typescript_1.isPropertyAssignment)(node) &&
+                (0, typescript_1.isIdentifier)(node.name) &&
+                node.name.text === 'recommended' &&
+                (0, typescript_1.isStringLiteral)(node.initializer)) {
+                changes.push({
+                    type: devkit_1.ChangeType.Delete,
+                    start: node.initializer.getStart(sourceFile),
+                    length: node.initializer.getWidth(sourceFile),
+                });
+                changes.push({
+                    type: devkit_1.ChangeType.Insert,
+                    index: node.initializer.getStart(sourceFile),
+                    text: "'recommended'",
+                });
+            }
+            else {
+                (0, typescript_1.forEachChild)(node, visit);
+            }
+        };
+        (0, typescript_1.forEachChild)(sourceFile, visit);
+        tree.write(path, (0, devkit_1.applyChangesToString)(contents, changes));
+    });
+}
+async function update(tree) {
+    updateJestConfig(tree);
+    updateTsConfigs(tree);
+    updateRecommended(tree);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = update;

package/src/migrations/update-17-2-0/simplify-eslint-patterns.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;

package/src/migrations/update-17-2-0/simplify-eslint-patterns.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+async function update(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const [projectName, projectConfiguration] of projects) {
+        let needsUpdate = false;
+        for (const [targetName, targetConfig] of Object.entries(projectConfiguration.targets ?? {})) {
+            if (targetConfig.executor !== '@nx/eslint:lint') {
+                continue;
+            }
+            needsUpdate = true;
+            if (projectConfiguration.targets[targetName].options?.lintFilePatterns) {
+                const rootPattern = getLintRoot(projectConfiguration);
+                const nonRootPatterns = projectConfiguration.targets[targetName].options.lintFilePatterns.filter((p) => !p.startsWith(rootPattern) && !p.startsWith('{projectRoot}'));
+                if (nonRootPatterns.length === 0 &&
+                    rootPattern === projectConfiguration.root) {
+                    // delete the lintFilePatterns option if it's the only option and matches the root of the project
+                    delete projectConfiguration.targets[targetName].options
+                        .lintFilePatterns;
+                    if (Object.keys(projectConfiguration.targets[targetName].options)
+                        .length === 0) {
+                        delete projectConfiguration.targets[targetName].options;
+                    }
+                }
+                else {
+                    projectConfiguration.targets[targetName].options.lintFilePatterns = [
+                        rootPattern,
+                        ...nonRootPatterns,
+                    ];
+                }
+            }
+        }
+        if (needsUpdate) {
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = update;
+function getLintRoot({ root, sourceRoot }) {
+    if (root === '' || root === '.') {
+        return sourceRoot || './src';
+    }
+    return root;
+}

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

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;

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

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

package/src/plugins/plugin.d.ts

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

package/src/plugins/plugin.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const globs_1 = require("nx/src/utils/globs");
+const workspace_context_1 = require("nx/src/utils/workspace-context");
+const config_file_1 = require("../utils/config-file");
+const DEFAULT_EXTENSIONS = ['ts', 'tsx', 'js', 'jsx', 'html', 'vue'];
+exports.createNodes = [
+    (0, globs_1.combineGlobPatterns)([
+        ...config_file_1.ESLINT_CONFIG_FILENAMES.map((f) => `**/${f}`),
+        config_file_1.baseEsLintConfigFile,
+        config_file_1.baseEsLintFlatConfigFile,
+    ]),
+    (configFilePath, options, context) => {
+        options = normalizeOptions(options);
+        // Ensure that configFiles are set, e2e-run fails due to them being undefined in CI (does not occur locally)
+        // TODO(JamesHenry): Further troubleshoot this in CI
+        context.configFiles = context.configFiles ?? [];
+        // Create a Set of all the directories containing eslint configs
+        const eslintRoots = new Set(context.configFiles.map(node_path_1.dirname));
+        const configDir = (0, node_path_1.dirname)(configFilePath);
+        const childProjectRoots = (0, workspace_context_1.globWithWorkspaceContext)(context.workspaceRoot, [
+            'project.json',
+            'package.json',
+            '**/project.json',
+            '**/package.json',
+        ].map((f) => (0, node_path_1.join)(configDir, f)))
+            .map((f) => (0, node_path_1.dirname)(f))
+            .filter((childProjectRoot) => {
+            // Filter out projects under other eslint configs
+            let root = childProjectRoot;
+            // Traverse up from the childProjectRoot to either the workspaceRoot or the dir of this config file
+            while (root !== (0, node_path_1.dirname)(root) && root !== (0, node_path_1.dirname)(configFilePath)) {
+                if (eslintRoots.has(root)) {
+                    return false;
+                }
+                root = (0, node_path_1.dirname)(root);
+            }
+            return true;
+        })
+            .filter((dir) => {
+            // Ignore project roots where the project does not contain any lintable files
+            const lintableFiles = (0, workspace_context_1.globWithWorkspaceContext)(context.workspaceRoot, [
+                (0, node_path_1.join)(dir, `**/*.{${options.extensions.join(',')}}`),
+            ]);
+            return lintableFiles.length > 0;
+        });
+        const uniqueChildProjectRoots = Array.from(new Set(childProjectRoots));
+        return {
+            projects: getProjectsUsingESLintConfig(configFilePath, uniqueChildProjectRoots, options, context),
+        };
+    },
+];
+function getProjectsUsingESLintConfig(configFilePath, childProjectRoots, options, context) {
+    const projects = {};
+    const rootEslintConfig = context.configFiles.find((f) => f === config_file_1.baseEsLintConfigFile ||
+        f === config_file_1.baseEsLintFlatConfigFile ||
+        config_file_1.ESLINT_CONFIG_FILENAMES.includes(f));
+    // Add a lint target for each child project without an eslint config, with the root level config as an input
+    for (const projectRoot of childProjectRoots) {
+        // If there's no src folder, it's not a standalone project, do not add the target at all
+        const isStandaloneWorkspace = projectRoot === '.' &&
+            (0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'src')) &&
+            (0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'package.json'));
+        if (projectRoot === '.' && !isStandaloneWorkspace) {
+            continue;
+        }
+        const eslintConfigs = [configFilePath];
+        if (rootEslintConfig && !eslintConfigs.includes(rootEslintConfig)) {
+            eslintConfigs.unshift(rootEslintConfig);
+        }
+        projects[projectRoot] = {
+            targets: buildEslintTargets(eslintConfigs, projectRoot, options, isStandaloneWorkspace),
+        };
+    }
+    return projects;
+}
+function buildEslintTargets(eslintConfigs, projectRoot, options, isStandaloneWorkspace = false) {
+    const isRootProject = projectRoot === '.';
+    const targets = {};
+    const targetConfig = {
+        command: `eslint ${isRootProject && isStandaloneWorkspace ? './src' : '.'}`,
+        cache: true,
+        options: {
+            cwd: projectRoot,
+        },
+        inputs: [
+            'default',
+            // Certain lint rules can be impacted by changes to dependencies
+            '^default',
+            ...eslintConfigs.map((config) => `{workspaceRoot}/${config}`.replace(`{workspaceRoot}/${projectRoot}`, isRootProject ? '{projectRoot}/' : '{projectRoot}')),
+            '{workspaceRoot}/tools/eslint-rules/**/*',
+            { externalDependencies: ['eslint'] },
+        ],
+    };
+    if (eslintConfigs.some((config) => (0, config_file_1.isFlatConfig)(config))) {
+        targetConfig.options.env = {
+            ESLINT_USE_FLAT_CONFIG: 'true',
+        };
+    }
+    targets[options.targetName] = targetConfig;
+    return targets;
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.targetName ??= 'lint';
+    // Normalize user input for extensions (strip leading . characters)
+    if (Array.isArray(options.extensions)) {
+        options.extensions = options.extensions.map((f) => f.replace(/^\.+/, ''));
+    }
+    else {
+        options.extensions = DEFAULT_EXTENSIONS;
+    }
+    return options;
+}

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

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

package/src/utils/config-file.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFlatConfig = exports.baseEsLintFlatConfigFile = exports.baseEsLintConfigFile = exports.ESLINT_CONFIG_FILENAMES = void 0;
+exports.ESLINT_CONFIG_FILENAMES = [
+    '.eslintrc',
+    '.eslintrc.js',
+    '.eslintrc.cjs',
+    '.eslintrc.yaml',
+    '.eslintrc.yml',
+    '.eslintrc.json',
+    'eslint.config.js',
+];
+exports.baseEsLintConfigFile = '.eslintrc.base.json';
+exports.baseEsLintFlatConfigFile = 'eslint.base.config.js';
+function isFlatConfig(configFilePath) {
+    return configFilePath.endsWith('.config.js');
+}
+exports.isFlatConfig = isFlatConfig;

package/src/utils/versions.d.ts

@@ -1,5 +1,5 @@
 export declare const nxVersion: any;
-export declare const eslintVersion = "~8.46.0";
+export declare const eslintVersion = "~8.57.0";
 export declare const eslintrcVersion = "^2.1.1";
 export declare const eslintConfigPrettierVersion = "^9.0.0";
-export declare const typescriptESLintVersion = "^5.60.1";
+export declare const typescriptESLintVersion = "^7.3.0";

package/src/utils/versions.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.typescriptESLintVersion = exports.eslintConfigPrettierVersion = exports.eslintrcVersion = exports.eslintVersion = exports.nxVersion = void 0;
 exports.nxVersion = require('../../package.json').version;
-exports.eslintVersion = '~8.46.0';
+exports.eslintVersion = '~8.57.0';
 exports.eslintrcVersion = '^2.1.1';
 exports.eslintConfigPrettierVersion = '^9.0.0';
-exports.typescriptESLintVersion = '^5.60.1';
+exports.typescriptESLintVersion = '^7.3.0';