@nx/eslint 23.0.0-beta.2 → 23.0.0-beta.21

package/{src → dist/src}/migrations/update-21-6-0/update-executor-lint-inputs.js

@@ -2,13 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
 async function default_1(tree) {
-    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const nxJson = (0, devkit_1.readNxJson)(tree) ?? {};
     const executor = '@nx/eslint:lint';
-    if (!nxJson.targetDefaults?.[executor]?.inputs) {
+    const existing = (0, internal_1.normalizeTargetDefaults)(nxJson.targetDefaults).find((e) => e.executor === executor &&
+        e.target === undefined &&
+        e.projects === undefined &&
+        e.plugin === undefined);
+    if (!existing?.inputs) {
         return;
     }
-    const inputs = nxJson.targetDefaults[executor].inputs;
+    const inputs = [...existing.inputs];
     if (!inputs.includes('^default')) {
         // Add after 'default' if present, otherwise at the beginning
         const defaultIndex = inputs.indexOf('default');
@@ -22,6 +27,7 @@ async function default_1(tree) {
     if (!inputs.includes('{workspaceRoot}/tools/eslint-rules/**/*')) {
         inputs.push('{workspaceRoot}/tools/eslint-rules/**/*');
     }
+    (0, internal_1.upsertTargetDefault)(tree, nxJson, { executor, inputs });
     (0, devkit_1.updateNxJson)(tree, nxJson);
     await (0, devkit_1.formatFiles)(tree);
 }

package/dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export default function rewriteInternalSubpathImports(tree: Tree): Promise<void>;
+export declare function rewriteSubpathImports(source: string): string;

package/dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rewriteInternalSubpathImports;
+exports.rewriteSubpathImports = rewriteSubpathImports;
+const devkit_1 = require("@nx/devkit");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const FROM_PREFIX = '@nx/eslint/src/';
+const TO_PUBLIC = '@nx/eslint';
+const TO_INTERNAL = '@nx/eslint/internal';
+// Symbols exported from `@nx/eslint`'s public entry (packages/eslint/index.ts).
+// A named import/export of one of these from `@nx/eslint/src/*` is routed to
+// the public `@nx/eslint` entry; everything else goes to `@nx/eslint/internal`.
+const PUBLIC_SYMBOLS = new Set([
+    'lintProjectGenerator',
+    'lintInitGenerator',
+    'Linter',
+    'LinterType',
+]);
+// Methods on `jest` and `vi` that take a module specifier as their first arg.
+const MOCK_HELPER_METHODS = new Set([
+    'mock',
+    'unmock',
+    'doMock',
+    'dontMock',
+    'requireActual',
+    'requireMock',
+    'importActual',
+    'importMock',
+]);
+let ts;
+async function rewriteInternalSubpathImports(tree) {
+    let touchedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!TS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original || !original.includes(FROM_PREFIX)) {
+            return;
+        }
+        const updated = rewriteSubpathImports(original);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Rewrote @nx/eslint/src/* imports in ${touchedCount} file(s) ` +
+            `(public symbols to @nx/eslint, internals to @nx/eslint/internal).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function rewriteSubpathImports(source) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    const changes = [];
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            collectImportRewrite(sourceFile, stmt, changes);
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, changes);
+        }
+    }
+    collectCallExpressionRewrites(sourceFile, changes);
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+function isSubpathSpecifier(node) {
+    return ts.isStringLiteral(node) && node.text.startsWith(FROM_PREFIX);
+}
+function collectImportRewrite(sourceFile, stmt, changes) {
+    if (!isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    const clause = stmt.importClause;
+    // Pure named imports (`import { a, b } from '...'`) can be split by symbol.
+    // A default or namespace import grabs the whole module, so it can't be
+    // split — route it wholesale to the internal entry.
+    if (clause &&
+        !clause.name &&
+        clause.namedBindings &&
+        ts.isNamedImports(clause.namedBindings)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, clause.isTypeOnly, clause.namedBindings.elements, 'import', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+function collectExportRewrite(sourceFile, stmt, changes) {
+    if (!stmt.moduleSpecifier || !isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    // `export { a, b } from '...'` can be split; `export * from '...'` cannot.
+    if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, stmt.isTypeOnly, stmt.exportClause.elements, 'export', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+/**
+ * Partition the named bindings of an import/export declaration into the ones
+ * that resolve to `@nx/eslint`'s public entry and the ones that don't. If both
+ * groups are non-empty, the single declaration is split into two.
+ */
+function rewriteNamedDeclaration(sourceFile, decl, specifier, isTypeOnly, elements, keyword, changes) {
+    const publicEls = [];
+    const internalEls = [];
+    for (const el of elements) {
+        // `propertyName` is the original name in `orig as alias`; fall back to
+        // `name` for the plain `orig` form.
+        const importedName = (el.propertyName ?? el.name).text;
+        (PUBLIC_SYMBOLS.has(importedName) ? publicEls : internalEls).push(el);
+    }
+    if (publicEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_INTERNAL, changes);
+        return;
+    }
+    if (internalEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_PUBLIC, changes);
+        return;
+    }
+    // Mixed — replace the whole declaration with one statement per target.
+    const quote = sourceFile.text.charAt(specifier.getStart(sourceFile));
+    const start = decl.getStart(sourceFile);
+    const end = decl.getEnd();
+    const semicolon = sourceFile.text.charAt(end - 1) === ';' ? ';' : '';
+    const prefix = isTypeOnly ? `${keyword} type` : keyword;
+    const render = (els, target) => `${prefix} { ${els
+        .map((el) => el.getText(sourceFile))
+        .join(', ')} } from ${quote}${target}${quote}${semicolon}`;
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${render(publicEls, TO_PUBLIC)}\n${render(internalEls, TO_INTERNAL)}`,
+    });
+}
+function collectCallExpressionRewrites(sourceFile, changes) {
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            shouldRewriteCallExpression(node) &&
+            node.arguments.length >= 1 &&
+            isSubpathSpecifier(node.arguments[0])) {
+            // `require(...)`, dynamic `import(...)` and `jest.mock(...)` reference
+            // the module as a whole and can't be symbol-split, so they go to the
+            // internal entry.
+            replaceSpecifier(sourceFile, node.arguments[0], TO_INTERNAL, changes);
+        }
+        else if (ts.isImportTypeNode(node)) {
+            // `typeof import('...')` parses as an `ImportTypeNode`, not a
+            // CallExpression — its argument is `LiteralTypeNode<StringLiteral>`.
+            // The whole module is referenced, so it can't be symbol-split.
+            const literal = getImportTypeStringLiteral(node);
+            if (literal && literal.text.startsWith(FROM_PREFIX)) {
+                replaceSpecifier(sourceFile, literal, TO_INTERNAL, changes);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+}
+function getImportTypeStringLiteral(node) {
+    const arg = node.argument;
+    if (arg && ts.isLiteralTypeNode(arg) && ts.isStringLiteral(arg.literal)) {
+        return arg.literal;
+    }
+    return undefined;
+}
+function shouldRewriteCallExpression(call) {
+    const callee = call.expression;
+    // `require('...')`
+    if (ts.isIdentifier(callee) && callee.text === 'require')
+        return true;
+    // dynamic `import('...')` (runtime form parses as a CallExpression whose
+    // callee is the `import` keyword). The `typeof import('...')` type-position
+    // form is an `ImportTypeNode` (handled in `collectCallExpressionRewrites`).
+    if (callee.kind === ts.SyntaxKind.ImportKeyword)
+        return true;
+    // `jest.mock(...)` / `vi.mock(...)` and friends.
+    if (ts.isPropertyAccessExpression(callee)) {
+        const obj = callee.expression;
+        if (ts.isIdentifier(obj) &&
+            (obj.text === 'jest' || obj.text === 'vi') &&
+            MOCK_HELPER_METHODS.has(callee.name.text)) {
+            return true;
+        }
+    }
+    return false;
+}
+function replaceSpecifier(sourceFile, literal, target, changes) {
+    const start = literal.getStart(sourceFile);
+    const end = literal.getEnd();
+    const quote = sourceFile.text.charAt(start);
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${quote}${target}${quote}`,
+    });
+}

package/{src → dist/src}/plugins/plugin.d.ts

@@ -5,4 +5,3 @@ export interface EslintPluginOptions {
 }
 export declare const createNodes: CreateNodesV2<EslintPluginOptions>;
 export declare const createNodesV2: CreateNodesV2<EslintPluginOptions>;
-//# sourceMappingURL=plugin.d.ts.map

package/{src → dist/src}/plugins/plugin.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodesV2 = exports.createNodes = void 0;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
 const js_1 = require("@nx/js");
-const internal_1 = require("@nx/js/src/internal");
+const internal_2 = require("@nx/js/internal");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const posix_1 = require("node:path/posix");
@@ -32,14 +32,6 @@ 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 internalCreateNodesV2 = async (ESLint, configFilePath, options, context, projectRootsByEslintRoots, lintableFilesPerProjectRoot, tsconfigChainsByProjectRoot, projectsCache, hashByRoot, pmc) => {
     const configDir = (0, posix_1.dirname)(configFilePath);
     const eslintVersion = ESLint.version;
@@ -53,13 +45,17 @@ const internalCreateNodesV2 = async (ESLint, configFilePath, options, context, p
         });
         return sharedEslint;
     };
-    const projects = {};
-    await Promise.all(projectRootsByEslintRoots.get(configDir).map(async (projectRoot) => {
+    // Collect each project root's contribution in parallel, but write
+    // them into `projects` afterwards in input order so insertion order
+    // (and therefore downstream merge order) is deterministic. Mutating
+    // `projects` from inside `Promise.all` would order keys by which
+    // async branch resolves first.
+    const orderedProjectRoots = projectRootsByEslintRoots.get(configDir) ?? [];
+    const contributions = await Promise.all(orderedProjectRoots.map(async (projectRoot) => {
         const hash = hashByRoot.get(projectRoot);
-        if (projectsCache[hash]) {
-            // We can reuse the projects in the cache.
-            Object.assign(projects, projectsCache[hash]);
-            return;
+        const cached = projectsCache.get(hash);
+        if (cached) {
+            return cached;
         }
         let hasNonIgnoredLintableFiles = false;
         if (configDir !== projectRoot || projectRoot === '.') {
@@ -76,20 +72,26 @@ const internalCreateNodesV2 = async (ESLint, configFilePath, options, context, p
         }
         if (!hasNonIgnoredLintableFiles) {
             // No lintable files in the project, store in the cache and skip further processing
-            projectsCache[hash] = {};
-            return;
+            projectsCache.set(hash, {});
+            return null;
         }
         const project = getProjectUsingESLintConfig(configFilePath, projectRoot, eslintVersion, options, context, pmc, tsconfigChainsByProjectRoot.get(projectRoot) ?? []);
         if (project) {
-            projects[projectRoot] = project;
+            const entry = { [projectRoot]: project };
             // Store project into the cache
-            projectsCache[hash] = { [projectRoot]: project };
-        }
-        else {
-            // No project found, store in the cache
-            projectsCache[hash] = {};
+            projectsCache.set(hash, entry);
+            return entry;
         }
+        // No project found, store in the cache
+        projectsCache.set(hash, {});
+        return null;
     }));
+    const projects = {};
+    for (const contribution of contributions) {
+        if (contribution) {
+            Object.assign(projects, contribution);
+        }
+    }
     return {
         projects,
     };
@@ -101,12 +103,12 @@ exports.createNodes = [
         const pmc = (0, devkit_1.getPackageManagerCommand)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
         const optionsHash = (0, file_hasher_1.hashObject)(options);
         const cachePath = (0, posix_1.join)(cache_directory_1.workspaceDataDirectory, `eslint-${optionsHash}.hash`);
-        const targetsCache = readTargetsCache(cachePath);
+        const targetsCache = new internal_1.PluginCache(cachePath);
         const { eslintConfigFiles, projectRoots, projectRootsByEslintRoots } = splitConfigFiles(configFiles);
         const lintableFilesPerProjectRoot = await collectLintableFilesByProjectRoot(projectRoots, options, context);
         const tsconfigChainsByProjectRoot = collectTsconfigChainsByProjectRoot(projectRoots, context.workspaceRoot);
         const lockFilePattern = (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
-        const hashes = await (0, calculate_hash_for_create_nodes_1.calculateHashesForCreateNodes)(projectRoots, options, context, projectRoots.map((root) => {
+        const hashes = await (0, internal_1.calculateHashesForCreateNodes)(projectRoots, options, context, projectRoots.map((root) => {
             const parentConfigs = eslintConfigFiles.filter((eslintConfig) => isSubDir(root, (0, posix_1.dirname)(eslintConfig)));
             return [
                 ...parentConfigs,
@@ -132,7 +134,7 @@ exports.createNodes = [
             return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => internalCreateNodesV2(ESLint, configFile, options, context, projectRootsByEslintRoots, lintableFilesPerProjectRoot, tsconfigChainsByProjectRoot, targetsCache, hashByRoot, pmc), eslintConfigFiles, options, context);
         }
         finally {
-            writeTargetsToCache(cachePath, targetsCache);
+            targetsCache.writeToDisk();
         }
     },
 ];
@@ -197,7 +199,7 @@ function collectTsconfigChainsByProjectRoot(projectRoots, workspaceRoot) {
             continue;
         const outside = [];
         const projectPrefix = `${projectRoot}/`;
-        (0, internal_1.walkTsconfigExtendsChain)((0, posix_1.join)(workspaceRoot, tsconfigPath), (absolutePath) => {
+        (0, internal_2.walkTsconfigExtendsChain)((0, posix_1.join)(workspaceRoot, tsconfigPath), (absolutePath) => {
             const wsRelative = (0, node_path_1.relative)(workspaceRoot, absolutePath)
                 .split(node_path_1.sep)
                 .join('/');

package/dist/src/utils/assert-supported-eslint-version.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function assertSupportedEslintVersion(tree: Tree): void;

package/dist/src/utils/assert-supported-eslint-version.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSupportedEslintVersion = assertSupportedEslintVersion;
+const internal_1 = require("@nx/devkit/internal");
+const versions_1 = require("./versions");
+function assertSupportedEslintVersion(tree) {
+    (0, internal_1.assertSupportedPackageVersion)(tree, 'eslint', versions_1.minSupportedEslintVersion);
+}

package/{src → dist/src}/utils/config-file.d.ts

@@ -8,4 +8,3 @@ export declare const legacyBaseEsLintFlatConfigFile = "eslint.base.config.js";
 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;
-//# sourceMappingURL=config-file.d.ts.map

package/dist/src/utils/deprecation.d.ts

@@ -0,0 +1,3 @@
+export declare const ESLINT_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/eslint:lint` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/eslint:convert-to-inferred` to migrate to the `@nx/eslint/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
+export declare function warnEslintExecutorDeprecation(): void;
+export declare function warnEslintExecutorGenerating(): void;

package/dist/src/utils/deprecation.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESLINT_EXECUTOR_DEPRECATION_MESSAGE = void 0;
+exports.warnEslintExecutorDeprecation = warnEslintExecutorDeprecation;
+exports.warnEslintExecutorGenerating = warnEslintExecutorGenerating;
+const devkit_1 = require("@nx/devkit");
+// TODO(v24): Remove the @nx/eslint:lint executor. The inferred plugin
+// (@nx/eslint/plugin) and the convert-to-inferred generator stay supported.
+exports.ESLINT_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/eslint:lint` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/eslint:convert-to-inferred` to migrate to the `@nx/eslint/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
+function warnEslintExecutorDeprecation() {
+    devkit_1.logger.warn(exports.ESLINT_EXECUTOR_DEPRECATION_MESSAGE);
+}
+function warnEslintExecutorGenerating() {
+    devkit_1.logger.warn('Generating a target that uses the deprecated `@nx/eslint:lint` executor. The executor will be removed in Nx v24. Run `nx g @nx/eslint:convert-to-inferred` next to migrate this target to the `@nx/eslint/plugin` inferred plugin and prevent future generators from emitting executor targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.');
+}

package/{src → dist/src}/utils/flat-config.d.ts

@@ -3,4 +3,3 @@ export declare const eslintFlatConfigFilenames: string[];
 export declare const baseEslintConfigFilenames: string[];
 export declare function getRootESLintFlatConfigFilename(tree: Tree): string;
 export declare function useFlatConfig(tree?: Tree): boolean;
-//# sourceMappingURL=flat-config.d.ts.map

package/{src → dist/src}/utils/resolve-eslint-class.d.ts

@@ -2,4 +2,3 @@ import type { ESLint } from 'eslint';
 export declare function resolveESLintClass(opts?: {
     useFlatConfigOverrideVal: boolean;
 }): Promise<typeof ESLint>;
-//# sourceMappingURL=resolve-eslint-class.d.ts.map

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveESLintClass = resolveESLintClass;
+const flat_config_1 = require("../utils/flat-config");
+async function resolveESLintClass(opts) {
+    try {
+        const shouldESLintUseFlatConfig = typeof opts?.useFlatConfigOverrideVal === 'boolean'
+            ? opts.useFlatConfigOverrideVal
+            : (0, flat_config_1.useFlatConfig)();
+        // In eslint 8.57.0 (the final v8 version), a dedicated API was added for resolving the correct ESLint class.
+        const eslintModule = (await import('eslint'));
+        if (typeof eslintModule.loadESLint === 'function') {
+            return (await eslintModule.loadESLint({
+                useFlatConfig: shouldESLintUseFlatConfig,
+            }));
+        }
+        // Explicitly use the FlatESLint and LegacyESLint classes here because the ESLint class points at a different one based on ESLint v8 vs ESLint v9
+        // But the decision on which one to use is not just based on the major version of ESLint.
+        const { LegacyESLint, FlatESLint } = await import('eslint/use-at-your-own-risk');
+        // LegacyESLint's type no longer structurally matches the flat ESLint class
+        // in v9 type defs (new static members like defaultConfig, fromOptionsModule),
+        // but at runtime either class is an appropriate return value here.
+        return (shouldESLintUseFlatConfig ? FlatESLint : LegacyESLint);
+    }
+    catch {
+        throw new Error('Unable to find `eslint`. Ensure a valid `eslint` version is installed.');
+    }
+}

package/{src → dist/src}/utils/rules-requiring-type-checking.d.ts

@@ -1,4 +1,3 @@
 import type { Linter } from 'eslint';
 export declare function hasRulesRequiringTypeChecking(eslintConfig: Linter.LegacyConfig): boolean;
 export declare function removeParserOptionsProjectIfNotRequired(json: Linter.LegacyConfig): Linter.LegacyConfig;
-//# sourceMappingURL=rules-requiring-type-checking.d.ts.map

package/dist/src/utils/versions.d.ts

@@ -0,0 +1,17 @@
+import { type Tree } from '@nx/devkit';
+export declare const nxVersion: any;
+export declare const minSupportedEslintVersion = "8.0.0";
+export declare const eslintConfigPrettierVersion = "^10.0.0";
+export declare const eslintrcVersion = "^2.1.1";
+export declare const jsoncEslintParserVersion = "^2.1.0";
+export declare const eslintCompat = "^1.1.1";
+export declare const eslintVersion = "^9.8.0";
+export declare const typescriptESLintVersion = "^8.40.0";
+type EslintVersions = {
+    eslintVersion: string;
+    typescriptESLintVersion: string;
+};
+export declare function versions(tree: Tree): EslintVersions;
+export declare function getInstalledEslintVersion(tree?: Tree): string | null;
+export declare function getInstalledEslintMajorVersion(tree?: Tree): number | null;
+export {};

package/dist/src/utils/versions.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescriptESLintVersion = exports.eslintVersion = exports.eslintCompat = exports.jsoncEslintParserVersion = exports.eslintrcVersion = exports.eslintConfigPrettierVersion = exports.minSupportedEslintVersion = exports.nxVersion = void 0;
+exports.versions = versions;
+exports.getInstalledEslintVersion = getInstalledEslintVersion;
+exports.getInstalledEslintMajorVersion = getInstalledEslintMajorVersion;
+const internal_1 = require("@nx/devkit/internal");
+const path_1 = require("path");
+const semver_1 = require("semver");
+const flat_config_1 = require("./flat-config");
+exports.nxVersion = require((0, path_1.join)('@nx/eslint', 'package.json')).version;
+exports.minSupportedEslintVersion = '8.0.0';
+exports.eslintConfigPrettierVersion = '^10.0.0';
+exports.eslintrcVersion = '^2.1.1';
+exports.jsoncEslintParserVersion = '^2.1.0';
+exports.eslintCompat = '^1.1.1';
+exports.eslintVersion = '^9.8.0';
+exports.typescriptESLintVersion = '^8.40.0';
+const latestVersions = {
+    eslintVersion: exports.eslintVersion,
+    typescriptESLintVersion: exports.typescriptESLintVersion,
+};
+const versionMap = {
+    8: {
+        eslintVersion: '~8.57.0',
+        typescriptESLintVersion: '^8.40.0',
+    },
+};
+function versions(tree) {
+    const installedEslintVersion = getInstalledEslintVersion(tree);
+    if (installedEslintVersion) {
+        const eslintMajorVersion = (0, semver_1.major)(installedEslintVersion);
+        return versionMap[eslintMajorVersion] ?? latestVersions;
+    }
+    // No ESLint declared yet — fresh installs honor the user's flat-config
+    // preference. Without flat config, install ESLint v8 (eslintrc lane); with
+    // flat config, install ESLint v9. Both lanes ship typescript-eslint v8 to
+    // match the `@nx/eslint-plugin` `@typescript-eslint/parser` peer.
+    return (0, flat_config_1.useFlatConfig)(tree) ? latestVersions : versionMap[8];
+}
+function getInstalledEslintVersion(tree) {
+    if (!tree) {
+        return (0, internal_1.getInstalledPackageVersion)('eslint');
+    }
+    return (0, internal_1.getDeclaredPackageVersion)(tree, 'eslint');
+}
+function getInstalledEslintMajorVersion(tree) {
+    const installedEslintVersion = getInstalledEslintVersion(tree);
+    return installedEslintVersion ? (0, semver_1.major)(installedEslintVersion) : null;
+}

package/{src → dist/src}/utils/workspace-lint-rules.d.ts

@@ -1,2 +1 @@
 export declare const workspaceLintPluginDir: string;
-//# sourceMappingURL=workspace-lint-rules.d.ts.map

package/executors.json

@@ -1,8 +1,8 @@
 {
   "executors": {
     "lint": {
-      "implementation": "./src/executors/lint/lint.impl",
-      "schema": "./src/executors/lint/schema.json",
+      "implementation": "./dist/src/executors/lint/lint.impl",
+      "schema": "./dist/src/executors/lint/schema.json",
       "description": "Run ESLint on a project."
     }
   }

package/generators.json

@@ -3,30 +3,30 @@
   "version": "0.1",
   "generators": {
     "init": {
-      "factory": "./src/generators/init/init#initEsLint",
-      "schema": "./src/generators/init/schema.json",
+      "factory": "./dist/src/generators/init/init#initEsLint",
+      "schema": "./dist/src/generators/init/schema.json",
       "description": "Set up the ESLint plugin.",
       "hidden": true
     },
     "workspace-rules-project": {
-      "factory": "./src/generators/workspace-rules-project/workspace-rules-project#lintWorkspaceRulesProjectGenerator",
-      "schema": "./src/generators/workspace-rules-project/schema.json",
+      "factory": "./dist/src/generators/workspace-rules-project/workspace-rules-project#lintWorkspaceRulesProjectGenerator",
+      "schema": "./dist/src/generators/workspace-rules-project/schema.json",
       "description": "Create the Workspace Lint Rules Project.",
       "hidden": true
     },
     "workspace-rule": {
-      "factory": "./src/generators/workspace-rule/workspace-rule#lintWorkspaceRuleGenerator",
-      "schema": "./src/generators/workspace-rule/schema.json",
+      "factory": "./dist/src/generators/workspace-rule/workspace-rule#lintWorkspaceRuleGenerator",
+      "schema": "./dist/src/generators/workspace-rule/schema.json",
       "description": "Create a new Workspace ESLint rule."
     },
     "convert-to-flat-config": {
-      "factory": "./src/generators/convert-to-flat-config/generator",
-      "schema": "./src/generators/convert-to-flat-config/schema.json",
+      "factory": "./dist/src/generators/convert-to-flat-config/generator",
+      "schema": "./dist/src/generators/convert-to-flat-config/schema.json",
       "description": "Convert an Nx workspace's ESLint configs to use Flat Config."
     },
     "convert-to-inferred": {
-      "factory": "./src/generators/convert-to-inferred/convert-to-inferred",
-      "schema": "./src/generators/convert-to-inferred/schema.json",
+      "factory": "./dist/src/generators/convert-to-inferred/convert-to-inferred",
+      "schema": "./dist/src/generators/convert-to-inferred/schema.json",
       "description": "Convert existing ESLint project(s) using `@nx/eslint:lint` executor to use `@nx/eslint/plugin`."
     }
   }

package/migrations.json

@@ -3,17 +3,28 @@
     "update-typescript-eslint-v8.13.0": {
       "version": "20.2.0-beta.5",
       "description": "Update TypeScript ESLint packages to v8.13.0 if they are already on v8",
-      "implementation": "./src/migrations/update-20-2-0/update-typescript-eslint-v8-13-0"
+      "implementation": "./dist/src/migrations/update-20-2-0/update-typescript-eslint-v8-13-0",
+      "requires": {
+        "@typescript-eslint/parser": ">=8.0.0"
+      }
     },
     "add-file-extensions-to-overrides": {
       "version": "20.3.0-beta.1",
       "description": "Update ESLint flat config to include .cjs, .mjs, .cts, and .mts files in overrides (if needed)",
-      "implementation": "./src/migrations/update-20-3-0/add-file-extensions-to-overrides"
+      "implementation": "./dist/src/migrations/update-20-3-0/add-file-extensions-to-overrides",
+      "requires": {
+        "eslint": ">=8.57.0"
+      }
     },
     "update-executor-lint-inputs": {
       "version": "22.7.0-beta.12",
       "description": "Add missing inputs to @nx/eslint:lint executor target defaults",
-      "implementation": "./src/migrations/update-21-6-0/update-executor-lint-inputs"
+      "implementation": "./dist/src/migrations/update-21-6-0/update-executor-lint-inputs"
+    },
+    "rewrite-eslint-internal-subpath-imports": {
+      "version": "23.0.0-beta.17",
+      "description": "Rewrites `@nx/eslint/src/*` subpath imports now that the `./src/*` subpath is no longer exposed by `@nx/eslint`'s exports map. Named imports/exports of public symbols are routed to `@nx/eslint` and the rest to the new `@nx/eslint/internal` entry; `require`, dynamic `import` and `jest.mock` calls reference the whole module and are routed to `@nx/eslint/internal`.",
+      "implementation": "./dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports"
     }
   },
   "packageJsonUpdates": {