@nx/eslint 0.0.0-pr-22179-271588f → 0.0.0-pr-26482-ebe2dba

package/src/generators/utils/flat-config/ast-utils.js

@@ -4,6 +4,11 @@ exports.generateAst = exports.mapFilePaths = exports.generateFlatOverride = expo
 const devkit_1 = require("@nx/devkit");
 const ts = require("typescript");
 const path_utils_1 = require("./path-utils");
+/**
+ * Supports direct identifiers, and those nested within an object (of arbitrary depth)
+ * E.g. `...foo` and `...foo.bar.baz.qux` etc
+ */
+const SPREAD_ELEMENTS_REGEXP = /\s*\.\.\.[a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)*,?\n?/g;
 /**
  * Remove all overrides from the config file
  */
@@ -58,11 +63,13 @@ function hasOverride(content, lookup) {
             let objSource;
             if (ts.isObjectLiteralExpression(node)) {
                 objSource = node.getFullText();
+                // strip any spread elements
+                objSource = objSource.replace(SPREAD_ELEMENTS_REGEXP, '');
             }
             else {
                 const fullNodeText = node['expression'].arguments[0].body.expression.getFullText();
                 // strip any spread elements
-                objSource = fullNodeText.replace(/\s*\.\.\.[a-zA-Z0-9_]+,?\n?/, '');
+                objSource = fullNodeText.replace(SPREAD_ELEMENTS_REGEXP, '');
             }
             const data = (0, devkit_1.parseJson)(objSource
                 // ensure property names have double quotes so that JSON.parse works
@@ -76,7 +83,6 @@ function hasOverride(content, lookup) {
     return false;
 }
 exports.hasOverride = hasOverride;
-const STRIP_SPREAD_ELEMENTS = /\s*\.\.\.[a-zA-Z0-9_]+,?\n?/g;
 function parseTextToJson(text) {
     return (0, devkit_1.parseJson)(text
         // ensure property names have double quotes so that JSON.parse works
@@ -105,7 +111,7 @@ function replaceOverride(content, root, lookup, update) {
             else {
                 const fullNodeText = node['expression'].arguments[0].body.expression.getFullText();
                 // strip any spread elements
-                objSource = fullNodeText.replace(STRIP_SPREAD_ELEMENTS, '');
+                objSource = fullNodeText.replace(SPREAD_ELEMENTS_REGEXP, '');
                 start =
                     node['expression'].arguments[0].body.expression.properties.pos +
                         (fullNodeText.length - objSource.length);
@@ -283,7 +289,7 @@ function removePlugin(content, pluginName, pluginImport) {
                         const pluginsArray = pluginsElem.initializer;
                         const plugins = parseTextToJson(pluginsElem.initializer
                             .getText()
-                            .replace(STRIP_SPREAD_ELEMENTS, ''));
+                            .replace(SPREAD_ELEMENTS_REGEXP, ''));
                         if (plugins.length > 1) {
                             changes.push({
                                 type: devkit_1.ChangeType.Delete,
@@ -419,7 +425,7 @@ function addCompatToFlatConfig(content) {
     if (result.includes('const compat = new FlatCompat')) {
         return result;
     }
-    result = addImportToFlatConfig(result, 'FlatCompat', '@eslint/eslintrc');
+    result = addImportToFlatConfig(result, ['FlatCompat'], '@eslint/eslintrc');
     const index = result.indexOf('module.exports');
     return (0, devkit_1.applyChangesToString)(result, [
         {
@@ -502,15 +508,33 @@ function generateFlatOverride(override) {
         !override.extends &&
         !override.plugins &&
         !override.parser) {
+        if (override.parserOptions) {
+            const { parserOptions, ...rest } = override;
+            return generateAst({ ...rest, languageOptions: { parserOptions } });
+        }
         return generateAst(override);
     }
-    const { files, excludedFiles, rules, ...rest } = override;
+    const { files, excludedFiles, rules, parserOptions, ...rest } = override;
     const objectLiteralElements = [
         ts.factory.createSpreadAssignment(ts.factory.createIdentifier('config')),
     ];
     addTSObjectProperty(objectLiteralElements, 'files', files);
     addTSObjectProperty(objectLiteralElements, 'excludedFiles', excludedFiles);
-    addTSObjectProperty(objectLiteralElements, 'rules', rules);
+    // Apply rules (and spread ...config.rules into it as the first assignment)
+    addTSObjectProperty(objectLiteralElements, 'rules', rules || {});
+    const rulesObjectAST = objectLiteralElements.pop();
+    const rulesObjectInitializer = rulesObjectAST.initializer;
+    const spreadAssignment = ts.factory.createSpreadAssignment(ts.factory.createIdentifier('config.rules'));
+    const updatedRulesProperties = [
+        spreadAssignment,
+        ...rulesObjectInitializer.properties,
+    ];
+    objectLiteralElements.push(ts.factory.createPropertyAssignment('rules', ts.factory.createObjectLiteralExpression(updatedRulesProperties, true)));
+    if (parserOptions) {
+        addTSObjectProperty(objectLiteralElements, 'languageOptions', {
+            parserOptions,
+        });
+    }
     return ts.factory.createSpreadElement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('compat'), ts.factory.createIdentifier('config')), undefined, [generateAst(rest)]), ts.factory.createIdentifier('map')), undefined, [
         ts.factory.createArrowFunction(undefined, undefined, [
             ts.factory.createParameterDeclaration(undefined, undefined, 'config'),

package/src/plugins/plugin.d.ts

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

package/src/plugins/plugin.js

@@ -1,92 +1,319 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodes = void 0;
-const path_1 = require("path");
-const fs_1 = require("fs");
+exports.createNodes = exports.createNodesV2 = void 0;
+const devkit_1 = require("@nx/devkit");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const file_hasher_1 = require("nx/src/hasher/file-hasher");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
 const globs_1 = require("nx/src/utils/globs");
+const workspace_context_1 = require("nx/src/utils/workspace-context");
+const semver_1 = require("semver");
 const config_file_1 = require("../utils/config-file");
+const resolve_eslint_class_1 = require("../utils/resolve-eslint-class");
+const DEFAULT_EXTENSIONS = ['ts', 'tsx', 'js', 'jsx', 'html', 'vue'];
+const PROJECT_CONFIG_FILENAMES = ['project.json', 'package.json'];
+const ESLINT_CONFIG_GLOB_V1 = (0, globs_1.combineGlobPatterns)(config_file_1.ESLINT_CONFIG_FILENAMES.map((f) => `**/${f}`));
+const ESLINT_CONFIG_GLOB_V2 = (0, globs_1.combineGlobPatterns)([
+    ...config_file_1.ESLINT_CONFIG_FILENAMES.map((f) => `**/${f}`),
+    ...PROJECT_CONFIG_FILENAMES.map((f) => `**/${f}`),
+]);
+function readTargetsCache(cachePath) {
+    return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && (0, node_fs_1.existsSync)(cachePath)
+        ? (0, devkit_1.readJsonFile)(cachePath)
+        : {};
+}
+function writeTargetsToCache(cachePath, results) {
+    (0, devkit_1.writeJsonFile)(cachePath, results);
+}
+const internalCreateNodes = async (configFilePath, options, context, projectsCache) => {
+    options = normalizeOptions(options);
+    const configDir = (0, node_path_1.dirname)(configFilePath);
+    // 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, and a
+    // list of globs to exclude from child projects
+    const nestedEslintRootPatterns = [];
+    for (const configFile of context.configFiles) {
+        const eslintRootDir = (0, node_path_1.dirname)(configFile);
+        if (eslintRootDir !== configDir && isSubDir(configDir, eslintRootDir)) {
+            nestedEslintRootPatterns.push(`${eslintRootDir}/**/*`);
+        }
+    }
+    const projectFiles = await (0, workspace_context_1.globWithWorkspaceContext)(context.workspaceRoot, ['project.json', 'package.json', '**/project.json', '**/package.json'].map((f) => (0, node_path_1.join)(configDir, f)), nestedEslintRootPatterns.length ? nestedEslintRootPatterns : undefined);
+    // dedupe and sort project roots by depth for more efficient traversal
+    const dedupedProjectRoots = Array.from(new Set(projectFiles.map((f) => (0, node_path_1.dirname)(f)))).sort((a, b) => (a !== b && isSubDir(a, b) ? -1 : 1));
+    const excludePatterns = dedupedProjectRoots.map((root) => `${root}/**/*`);
+    const ESLint = await (0, resolve_eslint_class_1.resolveESLintClass)((0, config_file_1.isFlatConfig)(configFilePath));
+    const eslintVersion = ESLint.version;
+    const projects = {};
+    await Promise.all(dedupedProjectRoots.map(async (childProjectRoot, index) => {
+        // anything after is either a nested project or a sibling project, can be excluded
+        const nestedProjectRootPatterns = excludePatterns.slice(index + 1);
+        // Ignore project roots where the project does not contain any lintable files
+        const lintableFiles = await (0, workspace_context_1.globWithWorkspaceContext)(context.workspaceRoot, [(0, node_path_1.join)(childProjectRoot, `**/*.{${options.extensions.join(',')}}`)], 
+        // exclude nested eslint roots and nested project roots
+        [...nestedEslintRootPatterns, ...nestedProjectRootPatterns]);
+        const parentConfigs = context.configFiles.filter((eslintConfig) => isSubDir(childProjectRoot, (0, node_path_1.dirname)(eslintConfig)));
+        const hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(childProjectRoot, options, context, [...parentConfigs, (0, node_path_1.join)(childProjectRoot, '.eslintignore')]);
+        if (projectsCache[hash]) {
+            // We can reuse the projects in the cache.
+            Object.assign(projects, projectsCache[hash]);
+            return;
+        }
+        const eslint = new ESLint({
+            cwd: (0, node_path_1.join)(context.workspaceRoot, childProjectRoot),
+        });
+        let hasNonIgnoredLintableFiles = false;
+        for (const file of lintableFiles) {
+            if (!(await eslint.isPathIgnored((0, node_path_1.join)(context.workspaceRoot, file)))) {
+                hasNonIgnoredLintableFiles = true;
+                break;
+            }
+        }
+        if (!hasNonIgnoredLintableFiles) {
+            // No lintable files in the project, store in the cache and skip further processing
+            projectsCache[hash] = {};
+            return;
+        }
+        const project = getProjectUsingESLintConfig(configFilePath, childProjectRoot, eslintVersion, options, context);
+        if (project) {
+            projects[childProjectRoot] = project;
+            // Store project into the cache
+            projectsCache[hash] = { [childProjectRoot]: project };
+        }
+        else {
+            // No project found, store in the cache
+            projectsCache[hash] = {};
+        }
+    }));
+    return {
+        projects,
+    };
+};
+let collectingLintableFilesPromise;
+const internalCreateNodesV2 = async (configFilePath, options, context, eslintConfigFiles, allProjectRoots, projectRootsByEslintRoots, lintableFilesPerProjectRoot, projectsCache) => {
+    const configDir = (0, node_path_1.dirname)(configFilePath);
+    const ESLint = await (0, resolve_eslint_class_1.resolveESLintClass)((0, config_file_1.isFlatConfig)(configFilePath));
+    const eslintVersion = ESLint.version;
+    const projects = {};
+    await Promise.all(projectRootsByEslintRoots.get(configDir).map(async (projectRoot) => {
+        const parentConfigs = eslintConfigFiles.filter((eslintConfig) => isSubDir(projectRoot, (0, node_path_1.dirname)(eslintConfig)));
+        const hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, {
+            configFiles: eslintConfigFiles,
+            nxJsonConfiguration: context.nxJsonConfiguration,
+            workspaceRoot: context.workspaceRoot,
+        }, [...parentConfigs, (0, node_path_1.join)(projectRoot, '.eslintignore')]);
+        if (projectsCache[hash]) {
+            // We can reuse the projects in the cache.
+            Object.assign(projects, projectsCache[hash]);
+            return;
+        }
+        if (!lintableFilesPerProjectRoot.size) {
+            collectingLintableFilesPromise ??= collectLintableFilesByProjectRoot(lintableFilesPerProjectRoot, allProjectRoots, options, context);
+            await collectingLintableFilesPromise;
+            collectingLintableFilesPromise = null;
+        }
+        const eslint = new ESLint({
+            cwd: (0, node_path_1.join)(context.workspaceRoot, projectRoot),
+        });
+        let hasNonIgnoredLintableFiles = false;
+        for (const file of lintableFilesPerProjectRoot.get(projectRoot) ?? []) {
+            if (!(await eslint.isPathIgnored((0, node_path_1.join)(context.workspaceRoot, file)))) {
+                hasNonIgnoredLintableFiles = true;
+                break;
+            }
+        }
+        if (!hasNonIgnoredLintableFiles) {
+            // No lintable files in the project, store in the cache and skip further processing
+            projectsCache[hash] = {};
+            return;
+        }
+        const project = getProjectUsingESLintConfig(configFilePath, projectRoot, eslintVersion, options, context);
+        if (project) {
+            projects[projectRoot] = project;
+            // Store project into the cache
+            projectsCache[hash] = { [projectRoot]: project };
+        }
+        else {
+            // No project found, store in the cache
+            projectsCache[hash] = {};
+        }
+    }));
+    return {
+        projects,
+    };
+};
+exports.createNodesV2 = [
+    ESLINT_CONFIG_GLOB_V2,
+    async (configFiles, options, context) => {
+        options = normalizeOptions(options);
+        const optionsHash = (0, file_hasher_1.hashObject)(options);
+        const cachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `eslint-${optionsHash}.hash`);
+        const targetsCache = readTargetsCache(cachePath);
+        const { eslintConfigFiles, projectRoots, projectRootsByEslintRoots } = splitConfigFiles(configFiles);
+        const lintableFilesPerProjectRoot = new Map();
+        try {
+            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => internalCreateNodesV2(configFile, options, context, eslintConfigFiles, projectRoots, projectRootsByEslintRoots, lintableFilesPerProjectRoot, targetsCache), eslintConfigFiles, options, context);
+        }
+        finally {
+            writeTargetsToCache(cachePath, targetsCache);
+        }
+    },
+];
 exports.createNodes = [
-    (0, globs_1.combineGlobPatterns)(['**/project.json', '**/package.json']),
+    ESLINT_CONFIG_GLOB_V1,
     (configFilePath, options, context) => {
-        const projectRoot = (0, path_1.dirname)(configFilePath);
-        options = normalizeOptions(options);
-        const eslintConfigs = getEslintConfigsForProject(projectRoot, context.workspaceRoot);
-        if (!eslintConfigs.length) {
-            return {};
-        }
-        return {
-            projects: {
-                [projectRoot]: {
-                    targets: buildEslintTargets(eslintConfigs, projectRoot, options),
-                },
-            },
-        };
+        devkit_1.logger.warn('`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.');
+        return internalCreateNodes(configFilePath, options, context, {});
     },
 ];
-function getEslintConfigsForProject(projectRoot, workspaceRoot) {
-    const detectedConfigs = new Set();
-    const baseConfig = (0, config_file_1.findBaseEslintFile)(workspaceRoot);
-    if (baseConfig) {
-        detectedConfigs.add(baseConfig);
+function splitConfigFiles(configFiles) {
+    const eslintConfigFiles = [];
+    const projectRoots = new Set();
+    for (const configFile of configFiles) {
+        if (PROJECT_CONFIG_FILENAMES.includes((0, node_path_1.basename)(configFile))) {
+            projectRoots.add((0, node_path_1.dirname)(configFile));
+        }
+        else {
+            eslintConfigFiles.push(configFile);
+        }
+    }
+    const uniqueProjectRoots = Array.from(projectRoots);
+    const projectRootsByEslintRoots = groupProjectRootsByEslintRoots(eslintConfigFiles, uniqueProjectRoots);
+    return {
+        eslintConfigFiles,
+        projectRoots: uniqueProjectRoots,
+        projectRootsByEslintRoots,
+    };
+}
+function groupProjectRootsByEslintRoots(eslintConfigFiles, projectRoots) {
+    const projectRootsByEslintRoots = new Map();
+    for (const eslintConfig of eslintConfigFiles) {
+        projectRootsByEslintRoots.set((0, node_path_1.dirname)(eslintConfig), []);
+    }
+    for (const projectRoot of projectRoots) {
+        const eslintRoot = getRootForDirectory(projectRoot, projectRootsByEslintRoots);
+        if (eslintRoot) {
+            projectRootsByEslintRoots.get(eslintRoot).push(projectRoot);
+        }
+    }
+    return projectRootsByEslintRoots;
+}
+async function collectLintableFilesByProjectRoot(lintableFilesPerProjectRoot, projectRoots, options, context) {
+    const lintableFiles = await (0, workspace_context_1.globWithWorkspaceContext)(context.workspaceRoot, [
+        `**/*.{${options.extensions.join(',')}}`,
+    ]);
+    for (const projectRoot of projectRoots) {
+        lintableFilesPerProjectRoot.set(projectRoot, []);
+    }
+    for (const file of lintableFiles) {
+        const projectRoot = getRootForDirectory((0, node_path_1.dirname)(file), lintableFilesPerProjectRoot);
+        if (projectRoot) {
+            lintableFilesPerProjectRoot.get(projectRoot).push(file);
+        }
+    }
+}
+function getRootForDirectory(directory, roots) {
+    let currentPath = (0, node_path_1.normalize)(directory);
+    while (currentPath !== (0, node_path_1.dirname)(currentPath)) {
+        if (roots.has(currentPath)) {
+            return currentPath;
+        }
+        currentPath = (0, node_path_1.dirname)(currentPath);
     }
-    let siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(workspaceRoot, projectRoot));
-    if (projectRoot === '.') {
-        // If there's no src folder, it's not a standalone project
-        if (!siblingFiles.includes('src')) {
-            return [];
-        }
-        // If it's standalone but doesn't have eslint config, it's not a lintable
-        const config = siblingFiles.find((f) => config_file_1.ESLINT_CONFIG_FILENAMES.includes(f));
-        if (!config) {
-            return [];
-        }
-        detectedConfigs.add(config);
-        return Array.from(detectedConfigs);
+    return roots.has(currentPath) ? currentPath : null;
+}
+function getProjectUsingESLintConfig(configFilePath, projectRoot, eslintVersion, options, context) {
+    const rootEslintConfig = [
+        config_file_1.baseEsLintConfigFile,
+        config_file_1.baseEsLintFlatConfigFile,
+        ...config_file_1.ESLINT_CONFIG_FILENAMES,
+    ].find((f) => (0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, f)));
+    // Add a lint target for each child project without an eslint config, with the root level config as an input
+    let standaloneSrcPath;
+    if (projectRoot === '.' &&
+        (0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'package.json'))) {
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'src'))) {
+            standaloneSrcPath = 'src';
+        }
+        else if ((0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'lib'))) {
+            standaloneSrcPath = 'lib';
+        }
     }
-    while (projectRoot !== '.') {
-        // if it has an eslint config it's lintable
-        const config = siblingFiles.find((f) => config_file_1.ESLINT_CONFIG_FILENAMES.includes(f));
-        if (config) {
-            detectedConfigs.add(`${projectRoot}/${config}`);
-            return Array.from(detectedConfigs);
-        }
-        projectRoot = (0, path_1.dirname)(projectRoot);
-        siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(workspaceRoot, projectRoot));
+    if (projectRoot === '.' && !standaloneSrcPath) {
+        return null;
     }
-    // check whether the root has an eslint config
-    const config = (0, fs_1.readdirSync)(workspaceRoot).find((f) => config_file_1.ESLINT_CONFIG_FILENAMES.includes(f));
-    if (config) {
-        detectedConfigs.add(config);
-        return Array.from(detectedConfigs);
+    const eslintConfigs = [configFilePath];
+    if (rootEslintConfig && !eslintConfigs.includes(rootEslintConfig)) {
+        eslintConfigs.unshift(rootEslintConfig);
     }
-    return [];
+    return {
+        targets: buildEslintTargets(eslintConfigs, eslintVersion, projectRoot, context.workspaceRoot, options, standaloneSrcPath),
+    };
 }
-function buildEslintTargets(eslintConfigs, projectRoot, options) {
+function buildEslintTargets(eslintConfigs, eslintVersion, projectRoot, workspaceRoot, options, standaloneSrcPath) {
     const isRootProject = projectRoot === '.';
     const targets = {};
     const targetConfig = {
-        command: `eslint ${isRootProject ? './src' : '.'}`,
+        command: `eslint ${isRootProject && standaloneSrcPath ? `./${standaloneSrcPath}` : '.'}`,
         cache: true,
         options: {
             cwd: projectRoot,
         },
         inputs: [
             'default',
-            ...eslintConfigs.map((config) => `{workspaceRoot}/${config}`),
+            // Certain lint rules can be impacted by changes to dependencies
+            '^default',
+            ...eslintConfigs.map((config) => `{workspaceRoot}/${config}`.replace(`{workspaceRoot}/${projectRoot}`, isRootProject ? '{projectRoot}/' : '{projectRoot}')),
+            ...((0, node_fs_1.existsSync)((0, node_path_1.join)(workspaceRoot, projectRoot, '.eslintignore'))
+                ? ['{projectRoot}/.eslintignore']
+                : []),
             '{workspaceRoot}/tools/eslint-rules/**/*',
             { externalDependencies: ['eslint'] },
         ],
+        outputs: ['{options.outputFile}'],
     };
-    if (eslintConfigs.some((config) => (0, config_file_1.isFlatConfig)(config))) {
+    // Always set the environment variable to ensure that the ESLint CLI can run on eslint v8 and v9
+    const useFlatConfig = eslintConfigs.some((config) => (0, config_file_1.isFlatConfig)(config));
+    // Flat config is default for 9.0.0+
+    const defaultSetting = (0, semver_1.gte)(eslintVersion, '9.0.0');
+    if (useFlatConfig !== defaultSetting) {
         targetConfig.options.env = {
-            ESLINT_USE_FLAT_CONFIG: 'true',
+            ESLINT_USE_FLAT_CONFIG: useFlatConfig ? 'true' : 'false',
         };
     }
     targets[options.targetName] = targetConfig;
     return targets;
 }
 function normalizeOptions(options) {
-    options ??= {};
-    options.targetName ??= 'lint';
-    return options;
+    const normalizedOptions = {
+        targetName: options.targetName ?? 'lint',
+    };
+    // Normalize user input for extensions (strip leading . characters)
+    if (Array.isArray(options.extensions)) {
+        normalizedOptions.extensions = options.extensions.map((f) => f.replace(/^\.+/, ''));
+    }
+    else {
+        normalizedOptions.extensions = DEFAULT_EXTENSIONS;
+    }
+    return normalizedOptions;
+}
+/**
+ * Determines if `child` is a subdirectory of `parent`. This is a simplified
+ * version that takes into account that paths are always relative to the
+ * workspace root.
+ */
+function isSubDir(parent, child) {
+    if (parent === '.') {
+        return true;
+    }
+    parent = (0, node_path_1.normalize)(parent);
+    child = (0, node_path_1.normalize)(child);
+    if (!parent.endsWith(node_path_1.sep)) {
+        parent += node_path_1.sep;
+    }
+    return child.startsWith(parent);
 }

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

@@ -1,5 +1,8 @@
+export declare const ESLINT_FLAT_CONFIG_FILENAMES: string[];
+export declare const ESLINT_OLD_CONFIG_FILENAMES: string[];
 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 findBaseEslintFile(workspaceRoot?: string): string | null;
 export declare function isFlatConfig(configFilePath: string): boolean;
+export declare function findFlatConfigFile(directory: string, workspaceRoot: string): string | null;
+export declare function findOldConfigFile(filePathOrDirectory: string, workspaceRoot: string): string | null;

package/src/utils/config-file.js

@@ -1,35 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFlatConfig = exports.findBaseEslintFile = exports.baseEsLintFlatConfigFile = exports.baseEsLintConfigFile = exports.ESLINT_CONFIG_FILENAMES = void 0;
-const devkit_1 = require("@nx/devkit");
+exports.findOldConfigFile = exports.findFlatConfigFile = exports.isFlatConfig = exports.baseEsLintFlatConfigFile = exports.baseEsLintConfigFile = exports.ESLINT_CONFIG_FILENAMES = exports.ESLINT_OLD_CONFIG_FILENAMES = exports.ESLINT_FLAT_CONFIG_FILENAMES = void 0;
 const fs_1 = require("fs");
-exports.ESLINT_CONFIG_FILENAMES = [
+const path_1 = require("path");
+// TODO(leo): add support for eslint.config.mjs and eslint.config.cjs
+exports.ESLINT_FLAT_CONFIG_FILENAMES = ['eslint.config.js'];
+exports.ESLINT_OLD_CONFIG_FILENAMES = [
     '.eslintrc',
     '.eslintrc.js',
     '.eslintrc.cjs',
     '.eslintrc.yaml',
     '.eslintrc.yml',
     '.eslintrc.json',
-    'eslint.config.js',
+];
+exports.ESLINT_CONFIG_FILENAMES = [
+    ...exports.ESLINT_OLD_CONFIG_FILENAMES,
+    ...exports.ESLINT_FLAT_CONFIG_FILENAMES,
 ];
 exports.baseEsLintConfigFile = '.eslintrc.base.json';
 exports.baseEsLintFlatConfigFile = 'eslint.base.config.js';
-function findBaseEslintFile(workspaceRoot = '') {
-    if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(workspaceRoot, exports.baseEsLintConfigFile))) {
-        return exports.baseEsLintConfigFile;
+function isFlatConfig(configFilePath) {
+    const configFileName = (0, path_1.basename)(configFilePath);
+    return exports.ESLINT_FLAT_CONFIG_FILENAMES.includes(configFileName);
+}
+exports.isFlatConfig = isFlatConfig;
+// https://eslint.org/docs/latest/use/configure/configuration-files#configuration-file-resolution
+function findFlatConfigFile(directory, workspaceRoot) {
+    let currentDir = (0, path_1.resolve)(workspaceRoot, directory);
+    while (true) {
+        const configFilePath = getConfigFileInDirectory(currentDir, exports.ESLINT_FLAT_CONFIG_FILENAMES);
+        if (configFilePath) {
+            return configFilePath;
+        }
+        if (currentDir === workspaceRoot) {
+            break;
+        }
+        currentDir = (0, path_1.dirname)(currentDir);
     }
-    if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(workspaceRoot, exports.baseEsLintFlatConfigFile))) {
-        return exports.baseEsLintFlatConfigFile;
+    return null;
+}
+exports.findFlatConfigFile = findFlatConfigFile;
+function findOldConfigFile(filePathOrDirectory, workspaceRoot) {
+    let currentDir = (0, path_1.resolve)(workspaceRoot, filePathOrDirectory);
+    if (!(0, fs_1.statSync)(currentDir).isDirectory()) {
+        currentDir = (0, path_1.dirname)(currentDir);
     }
-    for (const file of exports.ESLINT_CONFIG_FILENAMES) {
-        if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(workspaceRoot, file))) {
-            return file;
+    while (true) {
+        const configFilePath = getConfigFileInDirectory(currentDir, exports.ESLINT_OLD_CONFIG_FILENAMES);
+        if (configFilePath) {
+            return configFilePath;
         }
+        if (currentDir === workspaceRoot) {
+            break;
+        }
+        currentDir = (0, path_1.dirname)(currentDir);
     }
     return null;
 }
-exports.findBaseEslintFile = findBaseEslintFile;
-function isFlatConfig(configFilePath) {
-    return configFilePath.endsWith('.config.js');
+exports.findOldConfigFile = findOldConfigFile;
+function getConfigFileInDirectory(directory, candidateFileNames) {
+    for (const filename of candidateFileNames) {
+        const filePath = (0, path_1.join)(directory, filename);
+        if ((0, fs_1.existsSync)(filePath)) {
+            return filePath;
+        }
+    }
+    return null;
 }
-exports.isFlatConfig = isFlatConfig;

package/src/utils/resolve-eslint-class.d.ts

@@ -0,0 +1,2 @@
+import type { ESLint } from 'eslint';
+export declare function resolveESLintClass(useFlatConfig?: boolean): Promise<typeof ESLint>;

package/src/utils/resolve-eslint-class.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveESLintClass = void 0;
+async function resolveESLintClass(useFlatConfig = false) {
+    try {
+        // In eslint 8.57.0 (the final v8 version), a dedicated API was added for resolving the correct ESLint class.
+        const eslint = await Promise.resolve().then(() => require('eslint'));
+        if (typeof eslint.loadESLint === 'function') {
+            return await eslint.loadESLint({ useFlatConfig });
+        }
+        // If that API is not available (an older version of v8), we need to use the old way of resolving the ESLint class.
+        if (!useFlatConfig) {
+            return 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.');
+    }
+}
+exports.resolveESLintClass = resolveESLintClass;

package/src/utils/versions.d.ts

@@ -1,5 +1,5 @@
 export declare const nxVersion: any;
-export declare const eslintVersion = "~8.48.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 = "^6.13.2";
+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.48.0';
+exports.eslintVersion = '~8.57.0';
 exports.eslintrcVersion = '^2.1.1';
 exports.eslintConfigPrettierVersion = '^9.0.0';
-exports.typescriptESLintVersion = '^6.13.2';
+exports.typescriptESLintVersion = '^7.3.0';

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

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