@nx/eslint 23.0.0-beta.16 → 23.0.0-beta.18

package/{index.d.ts → dist/index.d.ts}

@@ -1,4 +1,3 @@
 export { lintProjectGenerator } from './src/generators/lint-project/lint-project';
 export { lintInitGenerator } from './src/generators/init/init';
 export { Linter, LinterType } from './src/generators/utils/linter';
-//# sourceMappingURL=index.d.ts.map

package/dist/internal.d.ts

@@ -0,0 +1,8 @@
+export { addExtendsToLintConfig, addIgnoresToLintConfig, addOverrideToLintConfig, addPluginsToLintConfig, addPredefinedConfigToFlatLintConfig, findEslintFile, isEslintConfigSupported, lintConfigHasOverride, replaceOverridesInLintConfig, updateOverrideInLintConfig, updateRelativePathsInConfig, } from './src/generators/utils/eslint-file';
+export { addImportToFlatConfig } from './src/generators/utils/flat-config/ast-utils';
+export { useFlatConfig } from './src/utils/flat-config';
+export { javaScriptOverride, typeScriptOverride, } from './src/generators/init/global-eslint-config';
+export { setupRootEsLint } from './src/generators/lint-project/setup-root-eslint';
+export { getInstalledEslintVersion, getTypeScriptEslintVersionToInstall, } from './src/utils/version-utils';
+export { eslint9__typescriptESLintVersion } from './src/utils/versions';
+export type { Schema } from './src/executors/lint/schema';

package/dist/internal.js

@@ -0,0 +1,34 @@
+"use strict";
+// Semi-private surface for first-party Nx packages.
+//
+// External plugins should NOT import from here — this entry is curated for
+// internal consumers and may change without semver protection. Mirrors
+// `@nx/devkit/internal`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eslint9__typescriptESLintVersion = exports.getTypeScriptEslintVersionToInstall = exports.getInstalledEslintVersion = exports.setupRootEsLint = exports.typeScriptOverride = exports.javaScriptOverride = exports.useFlatConfig = exports.addImportToFlatConfig = exports.updateRelativePathsInConfig = exports.updateOverrideInLintConfig = exports.replaceOverridesInLintConfig = exports.lintConfigHasOverride = exports.isEslintConfigSupported = exports.findEslintFile = exports.addPredefinedConfigToFlatLintConfig = exports.addPluginsToLintConfig = exports.addOverrideToLintConfig = exports.addIgnoresToLintConfig = exports.addExtendsToLintConfig = void 0;
+var eslint_file_1 = require("./src/generators/utils/eslint-file");
+Object.defineProperty(exports, "addExtendsToLintConfig", { enumerable: true, get: function () { return eslint_file_1.addExtendsToLintConfig; } });
+Object.defineProperty(exports, "addIgnoresToLintConfig", { enumerable: true, get: function () { return eslint_file_1.addIgnoresToLintConfig; } });
+Object.defineProperty(exports, "addOverrideToLintConfig", { enumerable: true, get: function () { return eslint_file_1.addOverrideToLintConfig; } });
+Object.defineProperty(exports, "addPluginsToLintConfig", { enumerable: true, get: function () { return eslint_file_1.addPluginsToLintConfig; } });
+Object.defineProperty(exports, "addPredefinedConfigToFlatLintConfig", { enumerable: true, get: function () { return eslint_file_1.addPredefinedConfigToFlatLintConfig; } });
+Object.defineProperty(exports, "findEslintFile", { enumerable: true, get: function () { return eslint_file_1.findEslintFile; } });
+Object.defineProperty(exports, "isEslintConfigSupported", { enumerable: true, get: function () { return eslint_file_1.isEslintConfigSupported; } });
+Object.defineProperty(exports, "lintConfigHasOverride", { enumerable: true, get: function () { return eslint_file_1.lintConfigHasOverride; } });
+Object.defineProperty(exports, "replaceOverridesInLintConfig", { enumerable: true, get: function () { return eslint_file_1.replaceOverridesInLintConfig; } });
+Object.defineProperty(exports, "updateOverrideInLintConfig", { enumerable: true, get: function () { return eslint_file_1.updateOverrideInLintConfig; } });
+Object.defineProperty(exports, "updateRelativePathsInConfig", { enumerable: true, get: function () { return eslint_file_1.updateRelativePathsInConfig; } });
+var ast_utils_1 = require("./src/generators/utils/flat-config/ast-utils");
+Object.defineProperty(exports, "addImportToFlatConfig", { enumerable: true, get: function () { return ast_utils_1.addImportToFlatConfig; } });
+var flat_config_1 = require("./src/utils/flat-config");
+Object.defineProperty(exports, "useFlatConfig", { enumerable: true, get: function () { return flat_config_1.useFlatConfig; } });
+var global_eslint_config_1 = require("./src/generators/init/global-eslint-config");
+Object.defineProperty(exports, "javaScriptOverride", { enumerable: true, get: function () { return global_eslint_config_1.javaScriptOverride; } });
+Object.defineProperty(exports, "typeScriptOverride", { enumerable: true, get: function () { return global_eslint_config_1.typeScriptOverride; } });
+var setup_root_eslint_1 = require("./src/generators/lint-project/setup-root-eslint");
+Object.defineProperty(exports, "setupRootEsLint", { enumerable: true, get: function () { return setup_root_eslint_1.setupRootEsLint; } });
+var version_utils_1 = require("./src/utils/version-utils");
+Object.defineProperty(exports, "getInstalledEslintVersion", { enumerable: true, get: function () { return version_utils_1.getInstalledEslintVersion; } });
+Object.defineProperty(exports, "getTypeScriptEslintVersionToInstall", { enumerable: true, get: function () { return version_utils_1.getTypeScriptEslintVersionToInstall; } });
+var versions_1 = require("./src/utils/versions");
+Object.defineProperty(exports, "eslint9__typescriptESLintVersion", { enumerable: true, get: function () { return versions_1.eslint9__typescriptESLintVersion; } });

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

@@ -1,2 +1 @@
 export { createNodes, createNodesV2, EslintPluginOptions, } from './src/plugins/plugin';
-//# sourceMappingURL=plugin.d.ts.map

package/{src → dist/src}/executors/lint/lint.impl.d.ts

@@ -3,4 +3,3 @@ import type { Schema } from './schema';
 export default function run(options: Schema, context: ExecutorContext): Promise<{
     success: boolean;
 }>;
-//# sourceMappingURL=lint.impl.d.ts.map

package/{src → dist/src}/executors/lint/utility/eslint-utils.d.ts

@@ -4,4 +4,3 @@ export declare function resolveAndInstantiateESLint(eslintConfigPath: string | u
     ESLint: typeof import("eslint").ESLint;
     eslint: ESLint;
 }>;
-//# sourceMappingURL=eslint-utils.d.ts.map

package/{src → dist/src}/generators/convert-to-flat-config/converters/json-converter.d.ts

@@ -10,4 +10,3 @@ export declare function convertEslintJsonToFlatConfig(tree: Tree, root: string,
     addESLintRC: boolean;
     addESLintJS: boolean;
 };
-//# sourceMappingURL=json-converter.d.ts.map

package/{src → dist/src}/generators/convert-to-flat-config/generator.d.ts

@@ -2,4 +2,3 @@ import { GeneratorCallback, Tree } from '@nx/devkit';
 import { ConvertToFlatConfigGeneratorSchema } from './schema';
 export declare function convertToFlatConfigGenerator(tree: Tree, options: ConvertToFlatConfigGeneratorSchema): Promise<void | GeneratorCallback>;
 export default convertToFlatConfigGenerator;
-//# sourceMappingURL=generator.d.ts.map

package/{src → dist/src}/generators/convert-to-inferred/convert-to-inferred.d.ts

@@ -5,4 +5,3 @@ interface Schema {
 }
 export declare function convertToInferred(tree: Tree, options: Schema): Promise<void>;
 export default convertToInferred;
-//# sourceMappingURL=convert-to-inferred.d.ts.map

package/{src → dist/src}/generators/convert-to-inferred/lib/target-options-map.d.ts

@@ -14,4 +14,3 @@ export declare const targetOptionsToCliMap: {
     reportUnusedDisableDirectives: string;
     printConfig: string;
 };
-//# sourceMappingURL=target-options-map.d.ts.map

package/{src → dist/src}/generators/init/global-eslint-config.d.ts

@@ -27,4 +27,3 @@ export declare const javaScriptOverride: {
 };
 export declare const getGlobalEsLintConfiguration: (unitTestRunner?: string, rootProject?: boolean) => Linter.LegacyConfig;
 export declare const getGlobalFlatEslintConfiguration: (format: "cjs" | "mjs", rootProject?: boolean) => string;
-//# sourceMappingURL=global-eslint-config.d.ts.map

package/{src → dist/src}/generators/init/init-migration.d.ts

@@ -1,4 +1,3 @@
 import { GeneratorCallback, ProjectConfiguration, TargetConfiguration, Tree } from '@nx/devkit';
 export declare function migrateConfigToMonorepoStyle(projects: ProjectConfiguration[], tree: Tree, unitTestRunner: string, eslintConfigFormat: 'mjs' | 'cjs', keepExistingVersions?: boolean): GeneratorCallback;
 export declare function findLintTarget(project: ProjectConfiguration): TargetConfiguration;
-//# sourceMappingURL=init-migration.d.ts.map

package/{src → dist/src}/generators/init/init.d.ts

@@ -8,4 +8,3 @@ export interface LinterInitOptions {
 }
 export declare function initEsLint(tree: Tree, options: LinterInitOptions): Promise<GeneratorCallback>;
 export declare function lintInitGenerator(tree: Tree, options: LinterInitOptions): Promise<GeneratorCallback>;
-//# sourceMappingURL=init.d.ts.map

package/{src → dist/src}/generators/lint-project/lint-project.d.ts

@@ -22,4 +22,3 @@ interface LintProjectOptions {
 export declare function lintProjectGenerator(tree: Tree, options: LintProjectOptions): Promise<GeneratorCallback>;
 export declare function lintProjectGeneratorInternal(tree: Tree, options: LintProjectOptions): Promise<GeneratorCallback>;
 export {};
-//# sourceMappingURL=lint-project.d.ts.map

package/{src → dist/src}/generators/lint-project/setup-root-eslint.d.ts

@@ -6,4 +6,3 @@ export type SetupRootEsLintOptions = {
     eslintConfigFormat?: 'mjs' | 'cjs';
 };
 export declare function setupRootEsLint(tree: Tree, options: SetupRootEsLintOptions): GeneratorCallback;
-//# sourceMappingURL=setup-root-eslint.d.ts.map

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

@@ -28,4 +28,3 @@ export declare function addPredefinedConfigToFlatLintConfig(tree: Tree, root: st
 export declare function addPluginsToLintConfig(tree: Tree, root: string, plugin: string | string[]): void;
 export declare function addIgnoresToLintConfig(tree: Tree, root: string, ignorePatterns: string[]): void;
 export declare function getPluginImport(pluginName: string): string;
-//# sourceMappingURL=eslint-file.d.ts.map

package/{src → dist/src}/generators/utils/eslint-targets.d.ts

@@ -1,3 +1,2 @@
 import { Tree } from '@nx/devkit';
 export declare function getEslintTargets(tree: Tree): Set<string>;
-//# sourceMappingURL=eslint-targets.d.ts.map

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

@@ -83,4 +83,3 @@ export declare function generateAst<T>(input: unknown, propertyAssignmentReplace
     keyToMatch: RegExp | string;
     replacer: (propertyAssignment: ts.PropertyAssignment, propertyName: string) => ts.PropertyAssignment;
 }): T;
-//# sourceMappingURL=ast-utils.d.ts.map

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

@@ -1,4 +1,3 @@
 import type { Linter } from 'eslint';
 export declare function updateFiles(override: Linter.ConfigOverride<Linter.RulesRecord>): Linter.ConfigOverride<Linter.RulesRecord>;
 export declare function mapFilePath(filePath: string): string;
-//# sourceMappingURL=path-utils.d.ts.map

package/{src → dist/src}/generators/utils/linter.d.ts

@@ -6,4 +6,3 @@ export declare enum Linter {
     None = "none"
 }
 export type LinterType = 'eslint' | 'none';
-//# sourceMappingURL=linter.d.ts.map

package/{src → dist/src}/generators/utils/plugin.d.ts

@@ -1,3 +1,2 @@
 import { Tree } from '@nx/devkit';
 export declare function hasEslintPlugin(tree: Tree): boolean;
-//# sourceMappingURL=plugin.d.ts.map

package/{src → dist/src}/generators/workspace-rule/workspace-rule.d.ts

@@ -4,4 +4,3 @@ export interface LintWorkspaceRuleGeneratorOptions {
     directory: string;
 }
 export declare function lintWorkspaceRuleGenerator(tree: Tree, options: LintWorkspaceRuleGeneratorOptions): Promise<GeneratorCallback>;
-//# sourceMappingURL=workspace-rule.d.ts.map

package/{src → dist/src}/generators/workspace-rules-project/workspace-rules-project.d.ts

@@ -6,4 +6,3 @@ export interface LintWorkspaceRulesProjectGeneratorOptions {
     addPlugin?: boolean;
 }
 export declare function lintWorkspaceRulesProjectGenerator(tree: Tree, options?: LintWorkspaceRulesProjectGeneratorOptions): Promise<GeneratorCallback>;
-//# sourceMappingURL=workspace-rules-project.d.ts.map

package/{src → dist/src}/migrations/update-20-2-0/update-typescript-eslint-v8-13-0.d.ts

@@ -1,3 +1,2 @@
 import { type GeneratorCallback, type Tree } from '@nx/devkit';
 export default function (tree: Tree): Promise<GeneratorCallback>;
-//# sourceMappingURL=update-typescript-eslint-v8-13-0.d.ts.map

package/dist/src/migrations/update-20-2-0/update-typescript-eslint-v8-13-0.md

@@ -0,0 +1,33 @@
+#### Update TypeScript ESLint to v8.13.0
+
+Update TypeScript ESLint packages to v8.13.0 if they are already on v8
+
+#### Sample Code Changes
+
+This migration will update `typescript-eslint`, `@typescript-eslint/eslint-plugin`, `@typescript-eslint/parser` and `@typescript-eslint/utils` to `8.13.0` if they are between version `8.0.0` and `8.13.0`.
+
+##### Before
+
+```json title="package.json"
+{
+  "devDependencies": {
+    "typescript-eslint": "^8.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "@typescript-eslint/utils": "^8.0.0"
+  }
+}
+```
+
+##### After
+
+```json title="package.json"
+{
+  "devDependencies": {
+    "typescript-eslint": "^8.13.0",
+    "@typescript-eslint/eslint-plugin": "^8.13.0",
+    "@typescript-eslint/parser": "^8.13.0",
+    "@typescript-eslint/utils": "^8.13.0"
+  }
+}
+```

package/{src → dist/src}/migrations/update-20-3-0/add-file-extensions-to-overrides.d.ts

@@ -1,3 +1,2 @@
 import { type Tree } from '@nx/devkit';
 export default function (tree: Tree): Promise<void>;
-//# sourceMappingURL=add-file-extensions-to-overrides.d.ts.map

package/dist/src/migrations/update-20-3-0/add-file-extensions-to-overrides.md

@@ -0,0 +1,83 @@
+#### Update ESLint Config File Extensions in Overrides
+
+Update ESLint flat config to include .cjs, .mjs, .cts, and .mts files in overrides (if needed)
+
+#### Sample Code Changes
+
+Add `.cjs`, `.mjs`, `.cts`, `.mts` file extensions to overrides converted using `convert-to-flat-config`
+
+##### Before
+
+```js title="eslint.config.js"
+const { FlatCompat } = require('@eslint/eslintrc');
+const js = require('@eslint/js');
+const nxEslintPlugin = require('@nx/eslint-plugin');
+
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+});
+
+module.exports = [
+  ...compat
+    .config({
+      extends: ['plugin:@nx/typescript'],
+    })
+    .map((config) => ({
+      ...config,
+      files: ['**/*.ts', '**/*.tsx'],
+      rules: {
+        ...config.rules,
+      },
+    })),
+  ...compat
+    .config({
+      extends: ['plugin:@nx/javascript'],
+    })
+    .map((config) => ({
+      ...config,
+      files: ['**/*.js', '**/*.jsx'],
+      rules: {
+        ...config.rules,
+      },
+    })),
+];
+```
+
+##### After
+
+```js title="eslint.config.js" {17,28}
+const { FlatCompat } = require('@eslint/eslintrc');
+const js = require('@eslint/js');
+const nxEslintPlugin = require('@nx/eslint-plugin');
+
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+});
+
+module.exports = [
+  ...compat
+    .config({
+      extends: ['plugin:@nx/typescript'],
+    })
+    .map((config) => ({
+      ...config,
+      files: ['**/*.ts', '**/*.tsx', '**/*.cts', '**/*.mts'],
+      rules: {
+        ...config.rules,
+      },
+    })),
+  ...compat
+    .config({
+      extends: ['plugin:@nx/javascript'],
+    })
+    .map((config) => ({
+      ...config,
+      files: ['**/*.js', '**/*.jsx', '**/*.cjs', '**/*.mjs'],
+      rules: {
+        ...config.rules,
+      },
+    })),
+];
+```

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

@@ -1,3 +1,2 @@
 import { type Tree } from '@nx/devkit';
 export default function (tree: Tree): Promise<void>;
-//# sourceMappingURL=update-executor-lint-inputs.d.ts.map

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,183 @@
+"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);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+}
+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 type-position form
+    // (`typeof import('...')`) is an `ImportTypeNode`, not a CallExpression, so
+    // we don't touch it.
+    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}/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/{src → dist/src}/utils/deprecation.d.ts

@@ -1,4 +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;
-//# sourceMappingURL=deprecation.d.ts.map

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/{src → dist/src}/utils/version-utils.d.ts

@@ -2,4 +2,3 @@ import { type Tree } from '@nx/devkit';
 export declare function getInstalledPackageVersion(pkgName: string, tree?: Tree): string | null;
 export declare function getInstalledEslintVersion(tree?: Tree): string | null;
 export declare function getTypeScriptEslintVersionToInstall(tree: Tree): string | null;
-//# sourceMappingURL=version-utils.d.ts.map

package/{src → dist/src}/utils/versions.d.ts

@@ -7,4 +7,3 @@ export declare const jsoncEslintParserVersion = "^2.1.0";
 export declare const eslint9__typescriptESLintVersion = "^8.40.0";
 export declare const eslint9__eslintVersion = "^9.8.0";
 export declare const eslintCompat = "^1.1.1";
-//# sourceMappingURL=versions.d.ts.map

package/{src → dist/src}/utils/versions.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.eslintCompat = exports.eslint9__eslintVersion = exports.eslint9__typescriptESLintVersion = exports.jsoncEslintParserVersion = exports.typescriptESLintVersion = exports.eslintConfigPrettierVersion = exports.eslintrcVersion = exports.eslintVersion = exports.nxVersion = void 0;
-exports.nxVersion = require('../../package.json').version;
+const path_1 = require("path");
+exports.nxVersion = require((0, path_1.join)('@nx/eslint', 'package.json')).version;
 exports.eslintVersion = '~8.57.0';
 exports.eslintrcVersion = '^2.1.1';
 exports.eslintConfigPrettierVersion = '^10.0.0';

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."
     }
   }