@nx/eslint 20.8.3 → 20.8.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/eslint",
-  "version": "20.8.3",
+  "version": "20.8.4",
   "private": false,
   "description": "The ESLint plugin for Nx contains executors, generators and utilities used for linting JavaScript/TypeScript projects within an Nx workspace.",
   "repository": {
@@ -35,8 +35,8 @@
     "eslint": "^8.0.0 || ^9.0.0"
   },
   "dependencies": {
-    "@nx/devkit": "20.8.3",
-    "@nx/js": "20.8.3",
+    "@nx/devkit": "20.8.4",
+    "@nx/js": "20.8.4",
     "semver": "^7.5.3",
     "tslib": "^2.3.0",
     "typescript": "~5.7.2"

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

@@ -8,7 +8,8 @@ export declare function addPatternsToFlatConfigIgnoresBlock(content: string, ign
 export declare function hasFlatConfigIgnoresBlock(content: string): boolean;
 export declare function hasOverride(content: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean): boolean;
 /**
- * Finds an override matching the lookup function and applies the update function to it
+ * Finds an override matching the lookup function and applies the update function to it.
+ * Uses property-level AST updates to preserve properties with variable references.
  */
 export declare function replaceOverride(content: string, root: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean, update?: (override: Partial<Linter.ConfigOverride<Linter.RulesRecord>>) => Partial<Linter.ConfigOverride<Linter.RulesRecord>>): string;
 /**

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

@@ -245,7 +245,52 @@ function extractPropertiesFromObjectLiteral(node) {
     return result;
 }
 /**
- * Finds an override matching the lookup function and applies the update function to it
+ * Find a property assignment node by name in an object literal.
+ */
+function findPropertyNode(node, propertyName) {
+    for (const prop of node.properties) {
+        if (ts.isPropertyAssignment(prop)) {
+            const name = prop.name.getText().replace(/['"]/g, '');
+            if (name === propertyName) {
+                return prop;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Find properties that are added, changed, or removed.
+ */
+function findChangedProperties(original, updated) {
+    const changed = [];
+    // Check modified/added properties
+    for (const key of Object.keys(updated)) {
+        if (JSON.stringify(original[key]) !== JSON.stringify(updated[key])) {
+            changed.push(key);
+        }
+    }
+    // Check removed properties
+    for (const key of Object.keys(original)) {
+        if (!(key in updated)) {
+            changed.push(key);
+        }
+    }
+    return changed;
+}
+/**
+ * Serialize a value to JavaScript source code. Handles converting eslintrc parser format to flat config format.
+ */
+function serializeValue(value, format) {
+    const parserReplacement = format === 'mjs'
+        ? (parser) => `(await import('${parser}'))`
+        : (parser) => `require('${parser}')`;
+    return JSON.stringify(value, null, 2)
+        .replace(/"parser": "([^"]+)"/g, (_, parser) => `"parser": ${parserReplacement(parser)}`)
+        .replaceAll(/\n/g, '\n    '); // Maintain indentation
+}
+/**
+ * Finds an override matching the lookup function and applies the update function to it.
+ * Uses property-level AST updates to preserve properties with variable references.
  */
 function replaceOverride(content, root, lookup, update) {
     const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
@@ -256,45 +301,78 @@ function replaceOverride(content, root, lookup, update) {
     }
     const changes = [];
     exportsArray.forEach((node) => {
-        if (isOverride(node)) {
-            let objSource;
-            let start, end;
-            if (ts.isObjectLiteralExpression(node)) {
-                objSource = node.getFullText();
-                start = node.properties.pos + 1; // keep leading line break
-                end = node.properties.end;
+        if (!isOverride(node)) {
+            return;
+        }
+        let objectLiteralNode;
+        if (ts.isObjectLiteralExpression(node)) {
+            objectLiteralNode = node;
+        }
+        else {
+            // Handle compat.config(...).map(...) pattern
+            const arrowBody = node['expression'].arguments[0].body.expression;
+            if (ts.isObjectLiteralExpression(arrowBody)) {
+                objectLiteralNode = arrowBody;
             }
             else {
-                const fullNodeText = node['expression'].arguments[0].body.expression.getFullText();
-                // strip any spread elements
-                objSource = fullNodeText.replace(SPREAD_ELEMENTS_REGEXP, '');
-                start =
-                    node['expression'].arguments[0].body.expression.properties.pos +
-                        (fullNodeText.length - objSource.length);
-                end = node['expression'].arguments[0].body.expression.properties.end;
+                return;
             }
-            const data = parseTextToJson(objSource);
-            if (lookup(data)) {
+        }
+        // Use AST-based extraction to handle variable references (e.g., plugins: { 'abc': abc })
+        const data = extractPropertiesFromObjectLiteral(objectLiteralNode);
+        if (lookup(data)) {
+            // Deep clone before update (update functions may mutate nested objects)
+            const originalData = structuredClone(data);
+            const updatedData = update?.(data);
+            // If update function was provided and returns undefined, delete the entire override block
+            if (update && updatedData === undefined) {
                 changes.push({
                     type: devkit_1.ChangeType.Delete,
-                    start,
-                    length: end - start,
+                    start: node.pos,
+                    length: node.end - node.pos + 1, // +1 for trailing comma
                 });
-                let updatedData = update(data);
-                if (updatedData) {
-                    updatedData = mapFilePaths(updatedData);
-                    const parserReplacement = format === 'mjs'
-                        ? (parser) => `(await import('${parser}'))`
-                        : (parser) => `require('${parser}')`;
-                    changes.push({
-                        type: devkit_1.ChangeType.Insert,
-                        index: start,
-                        text: '    ' +
-                            JSON.stringify(updatedData, null, 2)
-                                .replace(/"parser": "([^"]+)"/g, (_, parser) => `"parser": ${parserReplacement(parser)}`)
-                                .slice(2, -2) // Remove curly braces and start/end line breaks
-                                .replaceAll(/\n/g, '\n    '), // Maintain indentation
-                    });
+            }
+            else if (updatedData) {
+                const mappedData = mapFilePaths(updatedData);
+                const changedProps = findChangedProperties(originalData, mappedData);
+                for (const propName of changedProps) {
+                    const originalNode = findPropertyNode(objectLiteralNode, propName);
+                    const updatedValue = mappedData[propName];
+                    if (originalNode && !(propName in mappedData)) {
+                        // Delete property that was removed
+                        changes.push({
+                            type: devkit_1.ChangeType.Delete,
+                            start: originalNode.pos,
+                            length: originalNode.end - originalNode.pos,
+                        });
+                    }
+                    else if (originalNode) {
+                        // Replace existing property value
+                        const valueNode = originalNode.initializer;
+                        changes.push({
+                            type: devkit_1.ChangeType.Delete,
+                            start: valueNode.pos,
+                            length: valueNode.end - valueNode.pos,
+                        });
+                        changes.push({
+                            type: devkit_1.ChangeType.Insert,
+                            index: valueNode.pos,
+                            text: ' ' + serializeValue(updatedValue, format),
+                        });
+                    }
+                    else {
+                        // Add new property at the end of the object
+                        const lastProp = objectLiteralNode.properties[objectLiteralNode.properties.length - 1];
+                        const insertPos = lastProp
+                            ? lastProp.end
+                            : objectLiteralNode.pos + 1;
+                        const needsComma = lastProp ? ',' : '';
+                        changes.push({
+                            type: devkit_1.ChangeType.Insert,
+                            index: insertPos,
+                            text: `${needsComma}\n    "${propName}": ${serializeValue(updatedValue, format)}`,
+                        });
+                    }
                 }
             }
         }