@nx/eslint 23.1.0 → 23.1.1

package/dist/internal.d.ts

@@ -1,4 +1,4 @@
-export { addExtendsToLintConfig, addIgnoresToLintConfig, addOverrideToLintConfig, addPluginsToLintConfig, addPredefinedConfigToFlatLintConfig, findEslintFile, isEslintConfigSupported, lintConfigHasOverride, replaceOverridesInLintConfig, updateOverrideInLintConfig, updateRelativePathsInConfig, } from './src/generators/utils/eslint-file';
+export { addExtendsToLintConfig, addIgnoresToLintConfig, addOverrideToLintConfig, addPluginsToLintConfig, addPredefinedConfigToFlatLintConfig, addTypedLintingToFlatConfig, findEslintFile, inspectTypedLinting, isEslintConfigSupported, isTypedLintingEnabled, 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';

package/dist/internal.js

@@ -5,15 +5,18 @@
 // internal consumers and may change without semver protection. Mirrors
 // `@nx/devkit/internal`.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.versions = exports.typescriptESLintVersion = 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;
+exports.versions = exports.typescriptESLintVersion = exports.getInstalledEslintVersion = exports.setupRootEsLint = exports.typeScriptOverride = exports.javaScriptOverride = exports.useFlatConfig = exports.addImportToFlatConfig = exports.updateRelativePathsInConfig = exports.updateOverrideInLintConfig = exports.replaceOverridesInLintConfig = exports.lintConfigHasOverride = exports.isTypedLintingEnabled = exports.isEslintConfigSupported = exports.inspectTypedLinting = exports.findEslintFile = exports.addTypedLintingToFlatConfig = 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, "addTypedLintingToFlatConfig", { enumerable: true, get: function () { return eslint_file_1.addTypedLintingToFlatConfig; } });
 Object.defineProperty(exports, "findEslintFile", { enumerable: true, get: function () { return eslint_file_1.findEslintFile; } });
+Object.defineProperty(exports, "inspectTypedLinting", { enumerable: true, get: function () { return eslint_file_1.inspectTypedLinting; } });
 Object.defineProperty(exports, "isEslintConfigSupported", { enumerable: true, get: function () { return eslint_file_1.isEslintConfigSupported; } });
+Object.defineProperty(exports, "isTypedLintingEnabled", { enumerable: true, get: function () { return eslint_file_1.isTypedLintingEnabled; } });
 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; } });

package/dist/src/generators/lint-project/lint-project.d.ts

@@ -6,6 +6,10 @@ interface LintProjectOptions {
     eslintFilePatterns?: string[];
     tsConfigPaths?: string[];
     skipFormat: boolean;
+    enableTypedLinting?: boolean;
+    /**
+     * @deprecated Use `enableTypedLinting` instead. This option will be removed in Nx v24.
+     */
     setParserOptionsProject?: boolean;
     skipPackageJson?: boolean;
     unitTestRunner?: string;

package/dist/src/generators/lint-project/lint-project.js

@@ -99,7 +99,7 @@ async function lintProjectGeneratorInternal(tree, options) {
     if (!options.rootProject || projectConfig.root !== '.') {
         const addDependencyChecks = options.addPackageJsonDependencyChecks ||
             isBuildableLibraryProject(tree, projectConfig);
-        createEsLintConfiguration(tree, options, projectConfig, options.setParserOptionsProject, options.rootProject, addDependencyChecks);
+        createEsLintConfiguration(tree, options, projectConfig, (0, eslint_file_1.isTypedLintingEnabled)(options), options.rootProject, addDependencyChecks);
         if (addDependencyChecks) {
             tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, { 'jsonc-eslint-parser': versions_1.jsoncEslintParserVersion }, undefined, true));
         }
@@ -120,7 +120,7 @@ async function lintProjectGeneratorInternal(tree, options) {
     }
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
-function createEsLintConfiguration(tree, options, projectConfig, setParserOptionsProject, rootProject, addDependencyChecks) {
+function createEsLintConfiguration(tree, options, projectConfig, enableTypedLinting, rootProject, addDependencyChecks) {
     // we are only extending root for non-standalone projects or their complementary e2e apps
     const extendedRootConfig = rootProject ? undefined : (0, eslint_file_1.findEslintFile)(tree);
     const pathToRootConfig = extendedRootConfig
@@ -138,22 +138,11 @@ function createEsLintConfiguration(tree, options, projectConfig, setParserOption
             options.eslintConfigFormat = (0, eslint_file_1.determineEslintConfigFormat)(tree.read(extendedRootConfig, 'utf-8'));
         }
     }
+    // For flat configs, the typed-linting block is appended as a raw AST node
+    // below since `tsconfigRootDir` requires a non-JSON-serializable identifier
+    // (`import.meta.dirname` / `__dirname`).
     const overrides = (0, flat_config_1.useFlatConfig)(tree)
-        ? // For flat configs, keep generated overrides minimal; only add parserOptions when explicitly requested.
-            [
-                ...(setParserOptionsProject
-                    ? [
-                        {
-                            files: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
-                            languageOptions: {
-                                parserOptions: {
-                                    project: [`${projectConfig.root}/tsconfig.*?.json`],
-                                },
-                            },
-                        },
-                    ]
-                    : []),
-            ]
+        ? []
         : [
             {
                 files: ['*.ts', '*.tsx', '*.js', '*.jsx'],
@@ -170,7 +159,7 @@ function createEsLintConfiguration(tree, options, projectConfig, setParserOption
                  * parserOptions.project), the executor will attempt to look for the particular error typescript-eslint gives you
                  * and provide feedback to the user.
                  */
-                parserOptions: !setParserOptionsProject
+                parserOptions: !enableTypedLinting
                     ? undefined
                     : {
                         project: [`${projectConfig.root}/tsconfig.*?.json`],
@@ -214,6 +203,12 @@ function createEsLintConfiguration(tree, options, projectConfig, setParserOption
             importMap.set(pathToRootConfig, 'baseConfig');
             nodes.push((0, ast_utils_1.generateSpreadElement)('baseConfig'));
         }
+        // After the base config, never before it: ESLint merges `parserOptions`
+        // across entries and the last one wins, so this block's `project: null` only
+        // neutralizes a `project` the base config sets while it comes later.
+        if (enableTypedLinting) {
+            nodes.push((0, ast_utils_1.generateTypedLintingFlatConfigOverride)(options.eslintConfigFormat));
+        }
         overrides.forEach((override) => {
             nodes.push((0, ast_utils_1.generateFlatOverride)(override, options.eslintConfigFormat));
         });

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

@@ -4,6 +4,61 @@ export declare function findEslintFile(tree: Tree, projectRoot?: string): string
 export declare function isEslintConfigSupported(tree: Tree, projectRoot?: string): boolean;
 export declare function updateRelativePathsInConfig(tree: Tree, sourcePath: string, destinationPath: string): void;
 export declare function determineEslintConfigFormat(content: string): 'mjs' | 'cjs';
+/**
+ * Honors both `enableTypedLinting` and the deprecated `setParserOptionsProject`
+ * (slated for removal in Nx v24); either one truthy enables typed linting. A
+ * generator whose `enableTypedLinting` schema default is `false` must still
+ * honor a user who set the deprecated flag.
+ */
+export declare function isTypedLintingEnabled(options: {
+    enableTypedLinting?: boolean;
+    setParserOptionsProject?: boolean;
+}): boolean;
+/**
+ * What a config says about typed linting.
+ *
+ * Only keys inside a `parserOptions` object count, so an unrelated `project`
+ * (e.g. `settings['import/resolver'].typescript.project`) is not a false match.
+ * A local array the config spreads in is read too, since ESLint merges those
+ * entries in as if they were inline.
+ */
+export declare function inspectTypedLinting(content: string): TypedLintingReport;
+/**
+ * What a config configures for typed linting, read from its `parserOptions`
+ * (a local array it spreads in included, since ESLint merges those entries).
+ */
+export interface TypedLintingReport {
+    /**
+     * Typed-linting parser options are set at all, an explicit
+     * `projectService: false` opt-out included, since overwriting that would
+     * undo a deliberate choice.
+     */
+    own: boolean;
+    /**
+     * The project service is on, which covers every file the config applies to
+     * whichever tsconfig each one belongs to.
+     */
+    projectService: boolean;
+    /** A `project` typescript-eslint builds a program from is set. */
+    project: boolean;
+    /**
+     * A local `parserOptions` is present but set through an expression we can't
+     * read statically (a call, an imported reference, a dynamic key), so whether
+     * it configures typed linting is unknown. Distinct from a config that merely
+     * spreads in another file (no local `parserOptions`), which stays safe to
+     * append to.
+     */
+    uncertain: boolean;
+}
+/**
+ * Adds a typed-linting block (`parserOptions.projectService` + `tsconfigRootDir`)
+ * to a project's flat ESLint config. No-op for legacy `.eslintrc` configs, whose
+ * JSON format cannot express the `__dirname` that `tsconfigRootDir` needs.
+ *
+ * Use after operations that strip existing overrides (e.g.
+ * `replaceOverridesInLintConfig`) to re-establish typed linting.
+ */
+export declare function addTypedLintingToFlatConfig(tree: Tree, root: string): void;
 export declare function addOverrideToLintConfig(tree: Tree, root: string, override: Partial<Linter.ConfigOverride<Linter.RulesRecord>>, options?: {
     insertAtTheEnd?: boolean;
     checkBaseConfig?: boolean;

package/dist/src/generators/utils/eslint-file.js

@@ -4,6 +4,9 @@ exports.findEslintFile = findEslintFile;
 exports.isEslintConfigSupported = isEslintConfigSupported;
 exports.updateRelativePathsInConfig = updateRelativePathsInConfig;
 exports.determineEslintConfigFormat = determineEslintConfigFormat;
+exports.isTypedLintingEnabled = isTypedLintingEnabled;
+exports.inspectTypedLinting = inspectTypedLinting;
+exports.addTypedLintingToFlatConfig = addTypedLintingToFlatConfig;
 exports.addOverrideToLintConfig = addOverrideToLintConfig;
 exports.updateOverrideInLintConfig = updateOverrideInLintConfig;
 exports.lintConfigHasOverride = lintConfigHasOverride;
@@ -128,11 +131,689 @@ function offsetFilePath(projectRoot, pathToFile, offset, tree) {
     }
     return (0, devkit_1.joinPathFragments)(offset, projectRoot, pathToFile);
 }
+/**
+ * The module system a flat config file actually runs under. `.cts` and `.mts`
+ * fix it by extension, so the content is only a signal for the ambiguous ones
+ * (`.js`, `.ts`). Trusting content alone reads an idiomatic `export default` in
+ * a `.cts` as ESM and emits an `import.meta` its CommonJS output rejects.
+ */
+function determineEslintConfigFormatForFile(fileName, content) {
+    const extension = (0, posix_1.extname)(fileName);
+    if (extension === '.mjs' || extension === '.mts') {
+        return 'mjs';
+    }
+    if (extension === '.cjs' || extension === '.cts') {
+        return 'cjs';
+    }
+    return determineEslintConfigFormat(content);
+}
 function determineEslintConfigFormat(content) {
     const sourceFile = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true);
-    // Check if there's an `export default` in the AST
-    const hasExportDefault = sourceFile.statements.some((statement) => ts.isExportAssignment(statement) && !statement.isExportEquals);
-    return hasExportDefault ? 'mjs' : 'cjs';
+    return (0, ast_utils_1.isEsmExport)(sourceFile) ? 'mjs' : 'cjs';
+}
+/**
+ * Honors both `enableTypedLinting` and the deprecated `setParserOptionsProject`
+ * (slated for removal in Nx v24); either one truthy enables typed linting. A
+ * generator whose `enableTypedLinting` schema default is `false` must still
+ * honor a user who set the deprecated flag.
+ */
+function isTypedLintingEnabled(options) {
+    return !!(options.enableTypedLinting || options.setParserOptionsProject);
+}
+/**
+ * What a config says about typed linting.
+ *
+ * Only keys inside a `parserOptions` object count, so an unrelated `project`
+ * (e.g. `settings['import/resolver'].typescript.project`) is not a false match.
+ * A local array the config spreads in is read too, since ESLint merges those
+ * entries in as if they were inline.
+ */
+function inspectTypedLinting(content) {
+    const readings = findParserOptions(content);
+    const blocks = readings.filter(isReadParserOptions);
+    const own = blocks.some((block) => block.projectService !== 'absent' || block.enablesProject);
+    return {
+        own,
+        projectService: blocks.some((block) => block.projectService === 'enabled'),
+        project: blocks.some((block) => block.enablesProject),
+        // A local `parserOptions` set through an expression we can't read leaves
+        // typed linting undecided: appending would risk converting a `project`
+        // setup to the project service, so callers warn and skip. A definite setting
+        // (own) already decides the outcome, so it takes precedence.
+        uncertain: !own && readings.some((reading) => reading === UNREADABLE),
+    };
+}
+/**
+ * A `parserOptions` present in a config position whose value can't be read
+ * statically. It carries no settings, so it can't be a `ParserOptions`; it marks
+ * the result undecided rather than reading as no typed linting.
+ */
+const UNREADABLE = 'unreadable';
+function isReadParserOptions(reading) {
+    return reading !== UNREADABLE;
+}
+/**
+ * A legacy config can be JSON, JS or YAML, and a bare `.eslintrc` can be any of
+ * them, so each parser is tried in turn rather than picked from the filename.
+ * YAML goes last: a one-line JS config can parse as YAML into a mapping keyed on
+ * the whole line, which would otherwise preempt the parser that understands it.
+ */
+function findParserOptions(content) {
+    const eslintrc = tryParseJson(content);
+    if (eslintrc) {
+        return findParserOptionsInJson(eslintrc);
+    }
+    const blocks = findParserOptionsInSource(content);
+    if (blocks.length > 0) {
+        return blocks;
+    }
+    const yaml = tryParseYaml(content);
+    return yaml ? findParserOptionsInJson(yaml) : blocks;
+}
+function tryParseJson(content) {
+    try {
+        const parsed = (0, devkit_1.parseJson)(content);
+        return typeof parsed === 'object' && parsed !== null ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * `@zkochan/js-yaml` is an optional peer, so a workspace without it reads a YAML
+ * config as no typed linting, which is what happened before YAML was parsed at
+ * all.
+ */
+function tryParseYaml(content) {
+    try {
+        const { load } = require('@zkochan/js-yaml');
+        const parsed = load(content, { json: true });
+        return typeof parsed === 'object' && parsed !== null ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * A legacy config carries parser options at the top level and in each
+ * `overrides` entry, and ESLint rejects a nested `overrides`, so those are the
+ * only two places to read. Walking the whole document instead would pick up a
+ * `parserOptions` that configures something else, such as one inside a rule's
+ * options.
+ */
+function findParserOptionsInJson(config) {
+    const blocks = [];
+    const read = (entry) => {
+        const options = entry?.parserOptions;
+        if (typeof options === 'object' && options !== null) {
+            blocks.push(readJsonParserOptions(options));
+        }
+    };
+    read(config);
+    const { overrides } = config;
+    if (Array.isArray(overrides)) {
+        overrides.forEach(read);
+    }
+    return blocks;
+}
+function readJsonParserOptions(options) {
+    return {
+        projectService: !('projectService' in options)
+            ? 'absent'
+            : isFalsyValue(options.projectService)
+                ? 'disabled'
+                : 'enabled',
+        enablesProject: 'project' in options && !isFalsyValue(options.project),
+    };
+}
+function isFalsyValue(value) {
+    return value === false || value === null || value === undefined;
+}
+function findParserOptionsInSource(content) {
+    const { source, checker } = parseSource(content);
+    const configs = findConfigExpressions(source);
+    if (configs.length === 0) {
+        // No recognizable export (e.g. a `.eslintrc.js` legacy config, or a
+        // tokenizer-only fixture): scan the whole source. That can read a
+        // `parserOptions` from a declaration the config never uses, but a real flat
+        // config exports its array, so the structured walk covers those.
+        return collectParserOptions(source, checker, new Set());
+    }
+    const seen = new Set();
+    return configs.flatMap((config) => walkValue(config, checker, seen));
+}
+/**
+ * The value each config export denotes: `export default <expr>` (or `export =`)
+ * and `module.exports = <expr>`. Only exports declared in this file, so an export
+ * assembled in another module names nothing this walk reads.
+ */
+function findConfigExpressions(source) {
+    const expressions = [];
+    for (const statement of source.statements) {
+        if (ts.isExportAssignment(statement)) {
+            expressions.push(statement.expression);
+        }
+        else if (ts.isExpressionStatement(statement) &&
+            ts.isBinaryExpression(statement.expression) &&
+            statement.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            isModuleExports(statement.expression.left)) {
+            expressions.push(statement.expression.right);
+        }
+    }
+    return expressions;
+}
+/** The `module.exports` target of a CommonJS config's top-level assignment. */
+function isModuleExports(node) {
+    return (ts.isPropertyAccessExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'module' &&
+        node.name.text === 'exports');
+}
+const IGNORED_CONFIG_KEYS = new Set(['rules', 'settings', 'plugins']);
+/**
+ * A property whose value never holds real parser options, so the walk can skip
+ * its subtree. A rule's options, a `settings` value and a `plugins` map can each
+ * carry an object with a `parserOptions` key that configures something else;
+ * ESLint reads parser options only from `languageOptions`.
+ */
+function isIgnoredConfigKey(name) {
+    return IGNORED_CONFIG_KEYS.has(getPropertyName(name) ?? '');
+}
+/**
+ * Every `parserOptions` reachable from a config value, walking only the
+ * positions ESLint reads a config from: array entries, config-object property
+ * values (a `rules`/`settings`/`plugins` subtree skipped), object and array
+ * spreads, and the arguments of a wrapper call such as `tseslint.config(...)`. A
+ * name in any of those positions resolves to its local declaration, so a config
+ * assembled from `const` bindings reads the same as an inline one, and a name
+ * bound to an import (another file) resolves to nothing. `seen` guards a
+ * reference cycle.
+ *
+ * `inConfigPosition` tracks whether the value itself sits where ESLint reads a
+ * config from, as opposed to being an ordinary property value. A wrapper call
+ * forwards its arguments as config only in the former; in the latter it is an
+ * arbitrary function whose arguments stay unread.
+ */
+function walkValue(expression, checker, seen, inConfigPosition = true) {
+    const value = resolveExpressionValue(expression, checker, seen);
+    if (!value) {
+        return [];
+    }
+    if (ts.isArrayLiteralExpression(value)) {
+        // Elements inherit this array's position: a root config array holds config
+        // entries, an array under `files`/`ignores` holds ordinary values.
+        return value.elements.flatMap((element) => ts.isSpreadElement(element)
+            ? walkValue(element.expression, checker, seen, inConfigPosition)
+            : walkValue(element, checker, seen, inConfigPosition));
+    }
+    if (ts.isObjectLiteralExpression(value)) {
+        return value.properties.flatMap((property) => walkProperty(property, checker, seen));
+    }
+    if (ts.isCallExpression(value)) {
+        // A wrapper (`tseslint.config(cfg)`) forwards its arguments as config
+        // entries, but only when the call itself sits in a config position; as a
+        // property value (`files: getFiles({...})`) the call is arbitrary and its
+        // arguments are inputs, not config.
+        const results = inConfigPosition
+            ? value.arguments.flatMap((argument) => ts.isSpreadElement(argument)
+                ? walkValue(argument.expression, checker, seen)
+                : walkValue(argument, checker, seen))
+            : [];
+        // An IIFE (`(() => [...])()`) builds the config in the callee body, so read
+        // its returns unconditionally (unlike wrapper arguments), at this call's own
+        // position.
+        const callee = unwrapExpression(value.expression);
+        if (ts.isArrowFunction(callee) || ts.isFunctionExpression(callee)) {
+            for (const returned of returnedExpressions(callee)) {
+                results.push(...walkValue(returned, checker, seen, inConfigPosition));
+            }
+        }
+        return results;
+    }
+    if (ts.isConditionalExpression(value)) {
+        // Either branch of `cond ? a : b` may be the value at runtime, so a setting
+        // in either counts. The branches inherit this value's position.
+        return [
+            ...walkValue(value.whenTrue, checker, seen, inConfigPosition),
+            ...walkValue(value.whenFalse, checker, seen, inConfigPosition),
+        ];
+    }
+    if (ts.isBinaryExpression(value) && isShortCircuit(value.operatorToken)) {
+        // A short-circuit (`cond && cfg`, `base || [...]`, `base ?? [...]`) resolves
+        // to one operand; read both, since either may be the value at runtime.
+        return [
+            ...walkValue(value.left, checker, seen, inConfigPosition),
+            ...walkValue(value.right, checker, seen, inConfigPosition),
+        ];
+    }
+    if (ts.isBinaryExpression(value) &&
+        value.operatorToken.kind === ts.SyntaxKind.CommaToken) {
+        // A comma expression (`sideEffect(), cfg`) always evaluates to its right
+        // operand.
+        return walkValue(value.right, checker, seen, inConfigPosition);
+    }
+    return [];
+}
+/** The `&&`, `||` and `??` operators, whose result is one of their operands. */
+function isShortCircuit(operator) {
+    return (operator.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+        operator.kind === ts.SyntaxKind.BarBarToken ||
+        operator.kind === ts.SyntaxKind.QuestionQuestionToken);
+}
+/** The values an inline function returns: a concise arrow body, or each `return`. */
+function returnedExpressions(fn) {
+    if (!ts.isBlock(fn.body)) {
+        return [fn.body];
+    }
+    const expressions = [];
+    const visit = (node) => {
+        if (ts.isReturnStatement(node)) {
+            if (node.expression) {
+                expressions.push(node.expression);
+            }
+            return;
+        }
+        // A nested function has its own returns, unrelated to this one's value.
+        if (ts.isFunctionLike(node)) {
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(fn.body, visit);
+    return expressions;
+}
+/** The `parserOptions` a single config-object property contributes. */
+function walkProperty(property, checker, seen) {
+    if (ts.isSpreadAssignment(property)) {
+        return walkValue(property.expression, checker, seen, false);
+    }
+    const key = property.name ? getPropertyName(property.name) : null;
+    if (key && IGNORED_CONFIG_KEYS.has(key)) {
+        return [];
+    }
+    if (key === 'parserOptions') {
+        const object = getParserOptionsObject(property, checker);
+        return [object ? readParserOptions(object, checker) : UNREADABLE];
+    }
+    if (ts.isPropertyAssignment(property)) {
+        return walkValue(property.initializer, checker, seen, false);
+    }
+    if (ts.isShorthandPropertyAssignment(property)) {
+        // `{ languageOptions }`: follow the shorthand to its declaration and walk it.
+        const declaration = checker.getShorthandAssignmentValueSymbol(property)?.declarations?.[0];
+        if (declaration &&
+            ts.isVariableDeclaration(declaration) &&
+            declaration.initializer &&
+            !seen.has(declaration)) {
+            seen.add(declaration);
+            return walkValue(declaration.initializer, checker, seen, false);
+        }
+    }
+    return [];
+}
+/**
+ * Export-less fallback: every `parserOptions` reachable from a node, local array
+ * spreads followed. A spread of a local array contributes that array's entries;
+ * a spread of another module names no file this walk reads.
+ */
+function collectParserOptions(root, checker, localSeen) {
+    const blocks = [];
+    const visit = (node) => {
+        if (ts.isPropertyAssignment(node) && isIgnoredConfigKey(node.name)) {
+            return;
+        }
+        if (isParserOptionsProperty(node)) {
+            const object = getParserOptionsObject(node, checker);
+            blocks.push(object ? readParserOptions(object, checker) : UNREADABLE);
+        }
+        if (ts.isSpreadElement(node)) {
+            blocks.push(...followLocalSpread(node.expression, checker, localSeen));
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(root);
+    return blocks;
+}
+/**
+ * The expression a name (or an `obj.key` / `obj['key']` on a local object)
+ * ultimately denotes, following alias chains such as `const inner = [...]; const
+ * base = inner; export default base`. Anything we can't read statically (an
+ * import, a dynamic key) resolves to nothing. `seen` guards a cycle like
+ * `const a = b; const b = a`.
+ */
+function resolveExpressionValue(expression, checker, seen) {
+    const unwrapped = unwrapExpression(expression);
+    if (ts.isPropertyAccessExpression(unwrapped) ||
+        ts.isElementAccessExpression(unwrapped)) {
+        const value = resolveMemberValue(unwrapped, checker);
+        return value ? resolveExpressionValue(value, checker, seen) : null;
+    }
+    if (!ts.isIdentifier(unwrapped)) {
+        return unwrapped;
+    }
+    const declaration = checker.getSymbolAtLocation(unwrapped)?.declarations?.[0];
+    if (!declaration ||
+        !ts.isVariableDeclaration(declaration) ||
+        !declaration.initializer ||
+        seen.has(declaration)) {
+        return null;
+    }
+    seen.add(declaration);
+    return resolveExpressionValue(declaration.initializer, checker, seen);
+}
+/**
+ * The value at `obj.key` / `obj['key']` when `obj` resolves to a local object
+ * literal and the key is a static string. An imported object, a dynamic key or a
+ * missing property resolves to nothing. A fresh `seen` isolates the object lookup
+ * so sibling accesses on the same registry don't shadow one another.
+ */
+function resolveMemberValue(access, checker) {
+    const key = memberKey(access);
+    if (key === null) {
+        return null;
+    }
+    const object = resolveObjectExpression(access.expression, checker, new Set());
+    if (!object) {
+        return null;
+    }
+    return lookupObjectKey(object, key, checker, new Set()).value;
+}
+/**
+ * The value bound to `key` in an object literal, honoring source order (a later
+ * property or spread wins, as at runtime) across plain, shorthand and spread
+ * properties. `found` separates an absent key (an earlier value stands) from a
+ * present but unreadable one (it clears the earlier value); an unreadable spread
+ * object can't prove the key is present, so it leaves an earlier value in place.
+ * `seen` is the recursion stack, so a spread cycle stops while the same object
+ * reached again through a sibling spread still gets read.
+ */
+function lookupObjectKey(object, key, checker, seen) {
+    if (seen.has(object)) {
+        return { found: false, value: null };
+    }
+    seen.add(object);
+    let result = {
+        found: false,
+        value: null,
+    };
+    for (const property of object.properties) {
+        if (ts.isPropertyAssignment(property)) {
+            if (getPropertyName(property.name) === key) {
+                result = { found: true, value: property.initializer };
+            }
+        }
+        else if (ts.isShorthandPropertyAssignment(property)) {
+            if (property.name.text === key) {
+                result = { found: true, value: shorthandValue(property, checker) };
+            }
+        }
+        else if (ts.isSpreadAssignment(property)) {
+            const spread = resolveObjectExpression(property.expression, checker, new Set());
+            const fromSpread = spread
+                ? lookupObjectKey(spread, key, checker, seen)
+                : null;
+            if (fromSpread && fromSpread.found) {
+                result = fromSpread;
+            }
+        }
+    }
+    seen.delete(object);
+    return result;
+}
+/** The initializer a shorthand property's binding was declared with. */
+function shorthandValue(property, checker) {
+    const declaration = checker.getShorthandAssignmentValueSymbol(property)?.declarations?.[0];
+    return declaration &&
+        ts.isVariableDeclaration(declaration) &&
+        declaration.initializer
+        ? declaration.initializer
+        : null;
+}
+/** The static key of a member access, or `null` for a dynamic one. */
+function memberKey(access) {
+    if (ts.isPropertyAccessExpression(access)) {
+        return access.name.text;
+    }
+    const argument = access.argumentExpression;
+    if (ts.isStringLiteralLike(argument) || ts.isNumericLiteral(argument)) {
+        return argument.text;
+    }
+    return null;
+}
+/** A local array the config spreads in; its entries belong to this config. */
+function followLocalSpread(expression, checker, localSeen) {
+    // Only a name needs following. An inline array is already being walked as
+    // part of the surrounding config, so resolving it again would double-count.
+    // A name bound to an imported module resolves to nothing here (only a local
+    // declaration has an initializer to read), so a spread config from another
+    // file contributes nothing and the caller is free to append.
+    const unwrapped = unwrapExpression(expression);
+    if (!ts.isIdentifier(unwrapped)) {
+        return [];
+    }
+    const value = resolveExpressionValue(expression, checker, localSeen);
+    return value ? collectParserOptions(value, checker, localSeen) : [];
+}
+/**
+ * Parses the config with a type checker attached, so a `parserOptions` written
+ * as a reference resolves under real scope rules (shadowing, destructuring,
+ * parameters, imports) rather than an approximation of them. One in-memory
+ * file, no lib and no module resolution, so nothing reads from disk.
+ */
+function parseSource(content) {
+    // Parsed as TS: flat configs may be `.ts`/`.cts`/`.mts`, and TS is a superset,
+    // so the same parse covers the `.js` variants.
+    const fileName = 'eslint.config.ts';
+    const source = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const host = {
+        getSourceFile: (name) => (name === fileName ? source : undefined),
+        getDefaultLibFileName: () => 'lib.d.ts',
+        writeFile: () => { },
+        getCurrentDirectory: () => '',
+        getCanonicalFileName: (name) => name,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => '\n',
+        fileExists: (name) => name === fileName,
+        readFile: (name) => (name === fileName ? content : undefined),
+    };
+    const program = ts.createProgram([fileName], { noLib: true, allowJs: true, types: [] }, host);
+    return { source, checker: program.getTypeChecker() };
+}
+/** A `parserOptions` property, whether written in full or by ES shorthand. */
+function isParserOptionsProperty(node) {
+    return ((ts.isShorthandPropertyAssignment(node) &&
+        node.name.text === 'parserOptions') ||
+        (ts.isPropertyAssignment(node) &&
+            getPropertyName(node.name) === 'parserOptions'));
+}
+/**
+ * The `parserOptions` object a node contributes: an inline literal, or the
+ * literal behind a reference (`parserOptions: opts`, or the `{ parserOptions }`
+ * shorthand). A variable only counts once the config actually references it, so
+ * an unused declaration configures nothing.
+ */
+function getParserOptionsObject(node, checker) {
+    if (ts.isShorthandPropertyAssignment(node) &&
+        node.name.text === 'parserOptions') {
+        return resolveSymbolObject(checker.getShorthandAssignmentValueSymbol(node), checker, new Set());
+    }
+    if (!ts.isPropertyAssignment(node) ||
+        getPropertyName(node.name) !== 'parserOptions') {
+        return null;
+    }
+    return resolveObjectExpression(node.initializer, checker, new Set());
+}
+/**
+ * Strips the expression wrappers that don't change the value, so an object
+ * literal behind `as const`, `satisfies`, a non-null assertion or parentheses is
+ * still read as one.
+ */
+function unwrapExpression(node) {
+    let current = node;
+    while (ts.isParenthesizedExpression(current) ||
+        ts.isAsExpression(current) ||
+        ts.isSatisfiesExpression(current) ||
+        ts.isNonNullExpression(current) ||
+        ts.isTypeAssertionExpression(current)) {
+        current = current.expression;
+    }
+    return current;
+}
+/**
+ * The object literal an expression ultimately denotes, following alias chains
+ * (`const opts = typed`) and a static member access on a local object
+ * (`registry.opts`). Anything else the name could be bound to (a parameter, a
+ * destructured property, a call result, an import, a dynamic key) can't be read
+ * statically, so it resolves to nothing and leaves the config alone. `seen`
+ * guards against a cycle such as `const a = b; const b = a`.
+ */
+function resolveObjectExpression(expression, checker, seen) {
+    const unwrapped = unwrapExpression(expression);
+    if (ts.isObjectLiteralExpression(unwrapped)) {
+        return unwrapped;
+    }
+    if (ts.isPropertyAccessExpression(unwrapped) ||
+        ts.isElementAccessExpression(unwrapped)) {
+        const value = resolveMemberValue(unwrapped, checker);
+        return value ? resolveObjectExpression(value, checker, seen) : null;
+    }
+    if (!ts.isIdentifier(unwrapped) || seen.has(unwrapped)) {
+        return null;
+    }
+    seen.add(unwrapped);
+    return resolveSymbolObject(checker.getSymbolAtLocation(unwrapped), checker, seen);
+}
+/** The object literal behind a resolved name, if it was declared with one. */
+function resolveSymbolObject(symbol, checker, seen) {
+    const declaration = symbol?.declarations?.[0];
+    return declaration &&
+        ts.isVariableDeclaration(declaration) &&
+        declaration.initializer
+        ? resolveObjectExpression(declaration.initializer, checker, seen)
+        : null;
+}
+/**
+ * The properties a `parserOptions` object ends up with, spreads expanded in
+ * source order so a later entry overrides an earlier one, as it does at runtime.
+ * A value of `null` means the key is set to something we can't read (a shorthand
+ * or a nested reference). `seen` is the recursion stack, so a spread cycle stops
+ * while the same object spread again later still gets read.
+ */
+function flattenProperties(node, checker, seen) {
+    const properties = new Map();
+    let unreadable = false;
+    if (seen.has(node)) {
+        return { properties, unreadable };
+    }
+    seen.add(node);
+    for (const property of node.properties) {
+        if (ts.isSpreadAssignment(property)) {
+            const spread = resolveObjectExpression(property.expression, checker, new Set());
+            if (!spread) {
+                unreadable = true;
+                continue;
+            }
+            const nested = flattenProperties(spread, checker, seen);
+            unreadable ||= nested.unreadable;
+            for (const [key, value] of nested.properties) {
+                properties.set(key, value);
+            }
+            continue;
+        }
+        const key = property.name ? getPropertyName(property.name) : null;
+        if (!key) {
+            // A computed key could be either of the ones we look for.
+            unreadable = true;
+            continue;
+        }
+        properties.set(key, ts.isPropertyAssignment(property) ? property.initializer : null);
+    }
+    seen.delete(node);
+    return { properties, unreadable };
+}
+function readParserOptions(node, checker) {
+    const { properties, unreadable } = flattenProperties(node, checker, new Set());
+    const project = properties.get('project');
+    return {
+        projectService: !properties.has('projectService')
+            ? 'absent'
+            : isFalsyLiteral(properties.get('projectService'))
+                ? 'disabled'
+                : 'enabled',
+        // A shorthand (`{ project }`) hides its value, and an unreadable spread could
+        // carry any `project` at all; both count, since assuming typed linting is off
+        // risks appending a conflicting block over a working config.
+        enablesProject: unreadable || (properties.has('project') && !isFalsyLiteral(project)),
+    };
+}
+function getPropertyName(name) {
+    return ts.isIdentifier(name) ||
+        ts.isStringLiteral(name) ||
+        ts.isNumericLiteral(name)
+        ? name.text
+        : null;
+}
+function isFalsyLiteral(node) {
+    if (!node) {
+        return false;
+    }
+    return (node.kind === ts.SyntaxKind.FalseKeyword ||
+        node.kind === ts.SyntaxKind.NullKeyword ||
+        (ts.isIdentifier(node) && node.text === 'undefined'));
+}
+/**
+ * Adds a typed-linting block (`parserOptions.projectService` + `tsconfigRootDir`)
+ * to a project's flat ESLint config. No-op for legacy `.eslintrc` configs, whose
+ * JSON format cannot express the `__dirname` that `tsconfigRootDir` needs.
+ *
+ * Use after operations that strip existing overrides (e.g.
+ * `replaceOverridesInLintConfig`) to re-establish typed linting.
+ */
+function addTypedLintingToFlatConfig(tree, root) {
+    if (!(0, flat_config_1.useFlatConfig)(tree)) {
+        return;
+    }
+    let fileName;
+    for (const f of flat_config_1.eslintFlatConfigFilenames) {
+        if (tree.exists((0, devkit_1.joinPathFragments)(root, f))) {
+            fileName = (0, devkit_1.joinPathFragments)(root, f);
+            break;
+        }
+    }
+    if (!fileName) {
+        return;
+    }
+    const content = tree.read(fileName, 'utf8');
+    // Idempotent: leave the config alone only when it configures typed-linting
+    // parser options itself, an explicit `projectService: false` opt-out included.
+    // Typed linting a config merely spreads in from another file need not cover
+    // this project (its globs may be scoped elsewhere), and the appended block
+    // defuses any inherited `project` anyway, so it is no reason to skip.
+    const report = inspectTypedLinting(content);
+    if (report.own) {
+        return;
+    }
+    if (report.uncertain) {
+        // A local `parserOptions` set through an expression we can't read could
+        // already enable `project`; appending would silently convert it to the
+        // project service, so leave the config for the user to complete instead.
+        devkit_1.logger.warn(`Could not tell whether typed linting is already set up in "${fileName}" because its \`parserOptions\` is built from an expression Nx cannot read statically. Left it unchanged; add \`languageOptions: { parserOptions: { projectService: true } }\` yourself if typed linting is not configured.`);
+        return;
+    }
+    // The block carries `tsconfigRootDir`, whose value differs per module system,
+    // so the extension has to win over the content where it is decisive.
+    const format = determineEslintConfigFormatForFile(fileName, content);
+    const block = (0, ast_utils_1.generateTypedLintingFlatConfigOverride)(format);
+    const updated = (0, ast_utils_1.addBlockToFlatConfigExport)(content, block);
+    if (updated === content) {
+        // `addBlockToFlatConfigExport` only edits a plain array export
+        // (`export default [...]` / `module.exports = [...]`). A wrapper config such
+        // as `export default tseslint.config(...)` is left untouched, so warn rather
+        // than silently dropping the request.
+        devkit_1.logger.warn(`Could not enable typed linting in "${fileName}" because its ESLint flat config is not a plain array export. Add \`languageOptions: { parserOptions: { projectService: true } }\` to enable typed linting.`);
+        return;
+    }
+    tree.write(fileName, updated);
 }
 function addOverrideToLintConfig(tree, root, override, options = {
     insertAtTheEnd: true,
@@ -157,7 +838,7 @@ function addOverrideToLintConfig(tree, root, override, options = {
             }
         }
         let content = tree.read(fileName, 'utf8');
-        const format = content.includes('export default') ? 'mjs' : 'cjs';
+        const format = determineEslintConfigFormatForFile(fileName, content);
         const flatOverride = (0, ast_utils_1.generateFlatOverride)(override, format);
         // Check if the provided override using legacy eslintrc properties or plugins, if so we need to add compat
         if ((0, ast_utils_1.overrideNeedsCompat)(override)) {
@@ -271,7 +952,7 @@ function replaceOverridesInLintConfig(tree, root, overrides) {
             }
         }
         let content = tree.read(fileName, 'utf8');
-        const format = content.includes('export default') ? 'mjs' : 'cjs';
+        const format = determineEslintConfigFormatForFile(fileName, content);
         // Check if any of the provided overrides using legacy eslintrc properties or plugins, if so we need to add compat
         if (overrides.some(ast_utils_1.overrideNeedsCompat)) {
             content = (0, ast_utils_1.addFlatCompatToFlatConfig)(content);

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

@@ -25,6 +25,11 @@ export declare function addImportToFlatConfig(content: string, variable: string
  * Remove an import from flat config
  */
 export declare function removeImportFromFlatConfig(content: string, variable: string, imp: string): string;
+/**
+ * Whether a flat config uses an ESM `export default` (vs CJS `module.exports`).
+ * AST-based so a commented-out `export default` in a CJS file isn't misdetected.
+ */
+export declare function isEsmExport(source: ts.SourceFile): boolean;
 /**
  * Injects new ts.expression to the end of the module.exports or export default array.
  */
@@ -75,6 +80,12 @@ export declare function generateFlatOverride(_override: Partial<Linter.ConfigOve
     ignores?: Linter.FlatConfig['ignores'];
 }, format: 'mjs' | 'cjs', importsMap?: Map<string, string>): ts.ObjectLiteralExpression | ts.SpreadElement;
 export declare function generateFlatPredefinedConfig(predefinedConfigName: string, moduleName?: string, spread?: boolean): ts.ObjectLiteralExpression | ts.SpreadElement | ts.ElementAccessExpression;
+/**
+ * Generates a flat-config override block enabling typed linting via the
+ * project service. Default files match the typed-linting block that
+ * generators historically emitted via `parserOptions.project`.
+ */
+export declare function generateTypedLintingFlatConfigOverride(format: 'mjs' | 'cjs', files?: string[]): ts.ObjectLiteralExpression;
 export declare function mapFilePaths<T extends Partial<Linter.ConfigOverride<Linter.RulesRecord>>>(_override: T): T;
 /**
  * Generates an AST from a JSON-type input

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

@@ -7,6 +7,7 @@ exports.hasOverride = hasOverride;
 exports.replaceOverride = replaceOverride;
 exports.addImportToFlatConfig = addImportToFlatConfig;
 exports.removeImportFromFlatConfig = removeImportFromFlatConfig;
+exports.isEsmExport = isEsmExport;
 exports.addBlockToFlatConfigExport = addBlockToFlatConfigExport;
 exports.removePlugin = removePlugin;
 exports.removeCompatExtends = removeCompatExtends;
@@ -23,6 +24,7 @@ exports.generateESMImport = generateESMImport;
 exports.overrideNeedsCompat = overrideNeedsCompat;
 exports.generateFlatOverride = generateFlatOverride;
 exports.generateFlatPredefinedConfig = generateFlatPredefinedConfig;
+exports.generateTypedLintingFlatConfigOverride = generateTypedLintingFlatConfigOverride;
 exports.mapFilePaths = mapFilePaths;
 exports.generateAst = generateAst;
 const tslib_1 = require("tslib");
@@ -39,7 +41,7 @@ const SPREAD_ELEMENTS_REGEXP = /\s*\.\.\.[a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)*,?\n?/g;
  */
 function removeOverridesFromLintConfig(content) {
     const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
-    const format = content.includes('export default') ? 'mjs' : 'cjs';
+    const format = isEsmExport(source) ? 'mjs' : 'cjs';
     const exportsArray = format === 'mjs' ? findExportDefault(source) : findModuleExports(source);
     if (!exportsArray) {
         return content;
@@ -78,7 +80,7 @@ function findModuleExports(source) {
 }
 function addPatternsToFlatConfigIgnoresBlock(content, ignorePatterns) {
     const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
-    const format = content.includes('export default') ? 'mjs' : 'cjs';
+    const format = isEsmExport(source) ? 'mjs' : 'cjs';
     const exportsArray = format === 'mjs' ? findExportDefault(source) : findModuleExports(source);
     if (!exportsArray) {
         return content;
@@ -110,7 +112,7 @@ function addPatternsToFlatConfigIgnoresBlock(content, ignorePatterns) {
 }
 function hasFlatConfigIgnoresBlock(content) {
     const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
-    const format = content.includes('export default') ? 'mjs' : 'cjs';
+    const format = isEsmExport(source) ? 'mjs' : 'cjs';
     const exportsArray = format === 'mjs' ? findExportDefault(source) : findModuleExports(source);
     if (!exportsArray) {
         return false;
@@ -137,7 +139,7 @@ function isOverride(node) {
 }
 function hasOverride(content, lookup) {
     const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
-    const format = content.includes('export default') ? 'mjs' : 'cjs';
+    const format = isEsmExport(source) ? 'mjs' : 'cjs';
     const exportsArray = format === 'mjs' ? findExportDefault(source) : findModuleExports(source);
     if (!exportsArray) {
         return false;
@@ -295,7 +297,7 @@ function serializeValue(value, format) {
  */
 function replaceOverride(content, root, lookup, update) {
     const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
-    const format = content.includes('export default') ? 'mjs' : 'cjs';
+    const format = isEsmExport(source) ? 'mjs' : 'cjs';
     const exportsArray = format === 'mjs' ? findExportDefault(source) : findModuleExports(source);
     if (!exportsArray) {
         return content;
@@ -391,7 +393,7 @@ function replaceOverride(content, root, lookup, update) {
 function addImportToFlatConfig(content, variable, imp) {
     const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
     const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
-    const format = content.includes('export default') ? 'mjs' : 'cjs';
+    const format = isEsmExport(source) ? 'mjs' : 'cjs';
     if (format === 'mjs') {
         return addESMImportToFlatConfig(source, printer, content, variable, imp);
     }
@@ -547,7 +549,7 @@ function existsAsNamedOrDefaultImport(node, variable) {
  */
 function removeImportFromFlatConfig(content, variable, imp) {
     const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
-    const format = content.includes('export default') ? 'mjs' : 'cjs';
+    const format = isEsmExport(source) ? 'mjs' : 'cjs';
     if (format === 'mjs') {
         return removeImportFromFlatConfigESM(source, content, variable, imp);
     }
@@ -602,6 +604,13 @@ function removeImportFromFlatConfigCJS(source, content, variable, imp) {
     });
     return (0, devkit_1.applyChangesToString)(content, changes);
 }
+/**
+ * Whether a flat config uses an ESM `export default` (vs CJS `module.exports`).
+ * AST-based so a commented-out `export default` in a CJS file isn't misdetected.
+ */
+function isEsmExport(source) {
+    return source.statements.some((statement) => ts.isExportAssignment(statement) && !statement.isExportEquals);
+}
 /**
  * Injects new ts.expression to the end of the module.exports or export default array.
  */
@@ -610,7 +619,9 @@ function addBlockToFlatConfigExport(content, config, options = {
 }) {
     const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
     const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
-    const format = content.includes('export default') ? 'mjs' : 'cjs';
+    // AST-based format detection so `module.exports = [...]` files with a
+    // commented-out `export default` example aren't mis-routed to the ESM path.
+    const format = isEsmExport(source) ? 'mjs' : 'cjs';
     // find the export default array statement
     if (format === 'mjs') {
         return addBlockToFlatConfigExportESM(content, config, source, printer, options);
@@ -721,7 +732,7 @@ function addBlockToFlatConfigExportCJS(content, config, source, printer, options
 }
 function removePlugin(content, pluginName, pluginImport) {
     const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
-    const format = content.includes('export default') ? 'mjs' : 'cjs';
+    const format = isEsmExport(source) ? 'mjs' : 'cjs';
     const changes = [];
     if (format === 'mjs') {
         ts.forEachChild(source, function analyze(node) {
@@ -851,7 +862,7 @@ function removePlugin(content, pluginName, pluginImport) {
 function removeCompatExtends(content, compatExtends) {
     const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
     const changes = [];
-    const format = content.includes('export default') ? 'mjs' : 'cjs';
+    const format = isEsmExport(source) ? 'mjs' : 'cjs';
     const exportsArray = format === 'mjs' ? findExportDefault(source) : findModuleExports(source);
     if (!exportsArray) {
         return content;
@@ -890,7 +901,7 @@ function removeCompatExtends(content, compatExtends) {
 }
 function removePredefinedConfigs(content, moduleImport, moduleVariable, configs) {
     const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
-    const format = content.includes('export default') ? 'mjs' : 'cjs';
+    const format = isEsmExport(source) ? 'mjs' : 'cjs';
     const changes = [];
     let removeImport = true;
     const exportsArray = format === 'mjs' ? findExportDefault(source) : findModuleExports(source);
@@ -943,7 +954,8 @@ function addPluginsToExportsBlock(content, plugins) {
  */
 function addFlatCompatToFlatConfig(content) {
     const result = addImportToFlatConfig(content, 'js', '@eslint/js');
-    const format = content.includes('export default') ? 'mjs' : 'cjs';
+    const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+    const format = isEsmExport(source) ? 'mjs' : 'cjs';
     if (result.includes('const compat = new FlatCompat')) {
         return result;
     }
@@ -1172,8 +1184,17 @@ function generateFlatOverride(_override, format, importsMap) {
             },
         });
     }
-    // At this point we are applying the flat config compat tooling to the override
-    let { excludedFiles, parser, parserOptions, rules, files, ...rest } = override;
+    // At this point we are applying the flat config compat tooling to the override.
+    // Only destructure what Nx must remap or merge itself. Everything else, including
+    // parser and parserOptions, stays in `rest` so FlatCompat translates it: it resolves
+    // the parser to a module reference and hoists ecmaVersion/sourceType out of
+    // parserOptions, which re-emitting them by hand does not do.
+    let { excludedFiles, rules, files, ...rest } = override;
+    // eslintrc accepts `parser: null` to mean "use the default parser". Flat config
+    // has no null-parser concept and FlatCompat throws on it, so omit the key.
+    if (rest.parser === null) {
+        delete rest.parser;
+    }
     const objectLiteralElements = [
         ts.factory.createSpreadAssignment(ts.factory.createIdentifier('config')),
     ];
@@ -1211,11 +1232,6 @@ function generateFlatOverride(_override, format, importsMap) {
         ...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'),
@@ -1247,6 +1263,56 @@ function generateFlatPredefinedConfig(predefinedConfigName, moduleName = 'nx', s
     const node = ts.factory.createElementAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(moduleName), ts.factory.createIdentifier('configs')), ts.factory.createStringLiteral(predefinedConfigName));
     return spread ? ts.factory.createSpreadElement(node) : node;
 }
+const DEFAULT_TYPED_LINTING_FILES = [
+    '**/*.ts',
+    '**/*.tsx',
+    '**/*.js',
+    '**/*.jsx',
+];
+/**
+ * Generates the AST for a `parserOptions` object that enables typed linting
+ * via typescript-eslint's project service (the recommended approach since
+ * typescript-eslint v8).
+ *
+ * Emits `tsconfigRootDir: import.meta.dirname` for `mjs` and
+ * `tsconfigRootDir: __dirname` for `cjs`.
+ */
+function generateProjectServiceParserOptions(format) {
+    return ts.factory.createObjectLiteralExpression([
+        ts.factory.createPropertyAssignment('projectService', ts.factory.createTrue()),
+        generateProjectDefusingAssignment(),
+        ts.factory.createPropertyAssignment('tsconfigRootDir', format === 'mjs'
+            ? ts.factory.createPropertyAccessExpression(ts.factory.createMetaProperty(ts.SyntaxKind.ImportKeyword, ts.factory.createIdentifier('meta')), ts.factory.createIdentifier('dirname'))
+            : ts.factory.createIdentifier('__dirname')),
+    ], true);
+}
+/**
+ * ESLint merges `parserOptions` across every config entry matching a file, and
+ * typescript-eslint rejects a merged truthy `project` next to `projectService`.
+ * A config can pick one up from anywhere it extends, spreads in, or composes,
+ * and several of those routes cannot be read statically, so the block
+ * neutralizes it outright. The comment carries the condition for dropping it,
+ * since only the user can check what the configs they pull in set.
+ */
+function generateProjectDefusingAssignment() {
+    const assignment = ts.factory.createPropertyAssignment('project', ts.factory.createNull());
+    ts.addSyntheticLeadingComment(assignment, ts.SyntaxKind.SingleLineCommentTrivia, ' `projectService` conflicts with a `parserOptions.project` set by any config', true);
+    ts.addSyntheticLeadingComment(assignment, ts.SyntaxKind.SingleLineCommentTrivia, ' merged into this one. Remove this once you know none of them set it.', true);
+    return assignment;
+}
+/**
+ * Generates a flat-config override block enabling typed linting via the
+ * project service. Default files match the typed-linting block that
+ * generators historically emitted via `parserOptions.project`.
+ */
+function generateTypedLintingFlatConfigOverride(format, files = DEFAULT_TYPED_LINTING_FILES) {
+    return ts.factory.createObjectLiteralExpression([
+        ts.factory.createPropertyAssignment('files', ts.factory.createArrayLiteralExpression(files.map((f) => ts.factory.createStringLiteral(f)), true)),
+        ts.factory.createPropertyAssignment('languageOptions', ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment('parserOptions', generateProjectServiceParserOptions(format)),
+        ], true)),
+    ], true);
+}
 function mapFilePaths(_override) {
     const override = {
         ..._override,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/eslint",
-  "version": "23.1.0",
+  "version": "23.1.1",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -73,17 +73,17 @@
   "peerDependencies": {
     "@zkochan/js-yaml": "0.0.7",
     "eslint": "^9.0.0 || ^10.0.0",
-    "@nx/jest": "23.1.0"
+    "@nx/jest": "23.1.1"
   },
   "dependencies": {
     "semver": "^7.6.3",
     "tslib": "^2.3.0",
     "typescript": "~6.0.3",
-    "@nx/devkit": "23.1.0",
-    "@nx/js": "23.1.0"
+    "@nx/js": "23.1.1",
+    "@nx/devkit": "23.1.1"
   },
   "devDependencies": {
-    "nx": "23.1.0"
+    "nx": "23.1.1"
   },
   "peerDependenciesMeta": {
     "@nx/jest": {