@nx/eslint 0.0.0-pr-22179-271588f

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

@@ -0,0 +1,16 @@
+import type { Tree } from '@nx/devkit';
+import type { Linter } from 'eslint';
+export declare function findEslintFile(tree: Tree, projectRoot?: string): string | null;
+export declare function isEslintConfigSupported(tree: Tree, projectRoot?: string): boolean;
+export declare function updateRelativePathsInConfig(tree: Tree, sourcePath: string, destinationPath: string): void;
+export declare function addOverrideToLintConfig(tree: Tree, root: string, override: Linter.ConfigOverride<Linter.RulesRecord>, options?: {
+    insertAtTheEnd?: boolean;
+    checkBaseConfig?: boolean;
+}): void;
+export declare function updateOverrideInLintConfig(tree: Tree, root: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean, update: (override: Linter.ConfigOverride<Linter.RulesRecord>) => Linter.ConfigOverride<Linter.RulesRecord>): void;
+export declare function lintConfigHasOverride(tree: Tree, root: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean, checkBaseConfig?: boolean): boolean;
+export declare function replaceOverridesInLintConfig(tree: Tree, root: string, overrides: Linter.ConfigOverride<Linter.RulesRecord>[]): void;
+export declare function addExtendsToLintConfig(tree: Tree, root: string, plugin: string | string[]): void;
+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;

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

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPluginImport = exports.addIgnoresToLintConfig = exports.addPluginsToLintConfig = exports.addExtendsToLintConfig = exports.replaceOverridesInLintConfig = exports.lintConfigHasOverride = exports.updateOverrideInLintConfig = exports.addOverrideToLintConfig = exports.updateRelativePathsInConfig = exports.isEslintConfigSupported = exports.findEslintFile = void 0;
+const devkit_1 = require("@nx/devkit");
+const flat_config_1 = require("../../utils/flat-config");
+const ast_utils_1 = require("./flat-config/ast-utils");
+const path_utils_1 = require("./flat-config/path-utils");
+const config_file_1 = require("../../utils/config-file");
+function findEslintFile(tree, projectRoot) {
+    if (projectRoot === undefined && tree.exists(config_file_1.baseEsLintConfigFile)) {
+        return config_file_1.baseEsLintConfigFile;
+    }
+    if (projectRoot === undefined && tree.exists(config_file_1.baseEsLintFlatConfigFile)) {
+        return config_file_1.baseEsLintFlatConfigFile;
+    }
+    projectRoot ??= '';
+    for (const file of config_file_1.ESLINT_CONFIG_FILENAMES) {
+        if (tree.exists((0, devkit_1.joinPathFragments)(projectRoot, file))) {
+            return file;
+        }
+    }
+    return null;
+}
+exports.findEslintFile = findEslintFile;
+function isEslintConfigSupported(tree, projectRoot = '') {
+    const eslintFile = findEslintFile(tree, projectRoot);
+    if (!eslintFile) {
+        return false;
+    }
+    return eslintFile.endsWith('.json') || eslintFile.endsWith('.config.js');
+}
+exports.isEslintConfigSupported = isEslintConfigSupported;
+function updateRelativePathsInConfig(tree, sourcePath, destinationPath) {
+    if (sourcePath === destinationPath ||
+        !isEslintConfigSupported(tree, destinationPath)) {
+        return;
+    }
+    const configPath = (0, devkit_1.joinPathFragments)(destinationPath, findEslintFile(tree, destinationPath));
+    const offset = (0, devkit_1.offsetFromRoot)(destinationPath);
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const config = tree.read(configPath, 'utf-8');
+        tree.write(configPath, replaceFlatConfigPaths(config, sourcePath, offset, destinationPath, tree));
+    }
+    else {
+        (0, devkit_1.updateJson)(tree, configPath, (json) => {
+            if (typeof json.extends === 'string') {
+                json.extends = offsetFilePath(sourcePath, json.extends, offset, tree);
+            }
+            else if (json.extends) {
+                json.extends = json.extends.map((extend) => offsetFilePath(sourcePath, extend, offset, tree));
+            }
+            json.overrides?.forEach((o) => {
+                if (o.parserOptions?.project) {
+                    o.parserOptions.project = Array.isArray(o.parserOptions.project)
+                        ? o.parserOptions.project.map((p) => p.replace(sourcePath, destinationPath))
+                        : o.parserOptions.project.replace(sourcePath, destinationPath);
+                }
+            });
+            return json;
+        });
+    }
+}
+exports.updateRelativePathsInConfig = updateRelativePathsInConfig;
+function replaceFlatConfigPaths(config, sourceRoot, offset, destinationRoot, tree) {
+    let match;
+    let newConfig = config;
+    // replace requires
+    const requireRegex = RegExp(/require\(['"](.*)['"]\)/g);
+    while ((match = requireRegex.exec(newConfig)) !== null) {
+        const newPath = offsetFilePath(sourceRoot, match[1], offset, tree);
+        newConfig =
+            newConfig.slice(0, match.index) +
+                `require('${newPath}')` +
+                newConfig.slice(match.index + match[0].length);
+    }
+    // replace projects
+    const projectRegex = RegExp(/project:\s?\[?['"](.*)['"]\]?/g);
+    while ((match = projectRegex.exec(newConfig)) !== null) {
+        const newProjectDef = match[0].replaceAll(sourceRoot, destinationRoot);
+        newConfig =
+            newConfig.slice(0, match.index) +
+                newProjectDef +
+                newConfig.slice(match.index + match[0].length);
+    }
+    return newConfig;
+}
+function offsetFilePath(projectRoot, pathToFile, offset, tree) {
+    if (config_file_1.ESLINT_CONFIG_FILENAMES.some((eslintFile) => pathToFile.includes(eslintFile))) {
+        // if the file is point to base eslint
+        const rootEslint = findEslintFile(tree);
+        if (rootEslint) {
+            return (0, devkit_1.joinPathFragments)(offset, rootEslint);
+        }
+    }
+    if (!pathToFile.startsWith('..')) {
+        // not a relative path
+        return pathToFile;
+    }
+    return (0, devkit_1.joinPathFragments)(offset, projectRoot, pathToFile);
+}
+function addOverrideToLintConfig(tree, root, override, options = {
+    insertAtTheEnd: true,
+}) {
+    const isBase = options.checkBaseConfig && findEslintFile(tree, root).includes('.base');
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, isBase ? config_file_1.baseEsLintFlatConfigFile : 'eslint.config.js');
+        const flatOverride = (0, ast_utils_1.generateFlatOverride)(override);
+        let content = tree.read(fileName, 'utf8');
+        // we will be using compat here so we need to make sure it's added
+        if (overrideNeedsCompat(override)) {
+            content = (0, ast_utils_1.addCompatToFlatConfig)(content);
+        }
+        tree.write(fileName, (0, ast_utils_1.addBlockToFlatConfigExport)(content, flatOverride, options));
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, isBase ? config_file_1.baseEsLintConfigFile : '.eslintrc.json');
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            json.overrides ??= [];
+            if (options.insertAtTheEnd) {
+                json.overrides.push(override);
+            }
+            else {
+                json.overrides.unshift(override);
+            }
+            return json;
+        });
+    }
+}
+exports.addOverrideToLintConfig = addOverrideToLintConfig;
+function overrideNeedsCompat(override) {
+    return (override.env || override.extends || override.plugins || override.parser);
+}
+function updateOverrideInLintConfig(tree, root, lookup, update) {
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, 'eslint.config.js');
+        let content = tree.read(fileName, 'utf8');
+        content = (0, ast_utils_1.replaceOverride)(content, root, lookup, update);
+        tree.write(fileName, content);
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, '.eslintrc.json');
+        if (!tree.exists(fileName)) {
+            return;
+        }
+        const existingJson = (0, devkit_1.readJson)(tree, fileName);
+        if (!existingJson.overrides || !existingJson.overrides.some(lookup)) {
+            return;
+        }
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            const index = json.overrides.findIndex(lookup);
+            if (index !== -1) {
+                const newOverride = update(json.overrides[index]);
+                if (newOverride) {
+                    json.overrides[index] = newOverride;
+                }
+                else {
+                    json.overrides.splice(index, 1);
+                }
+            }
+            return json;
+        });
+    }
+}
+exports.updateOverrideInLintConfig = updateOverrideInLintConfig;
+function lintConfigHasOverride(tree, root, lookup, checkBaseConfig = false) {
+    if (!isEslintConfigSupported(tree, root)) {
+        return false;
+    }
+    const isBase = checkBaseConfig && findEslintFile(tree, root).includes('.base');
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, isBase ? config_file_1.baseEsLintFlatConfigFile : 'eslint.config.js');
+        const content = tree.read(fileName, 'utf8');
+        return (0, ast_utils_1.hasOverride)(content, lookup);
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, isBase ? config_file_1.baseEsLintConfigFile : '.eslintrc.json');
+        return (0, devkit_1.readJson)(tree, fileName).overrides?.some(lookup) || false;
+    }
+}
+exports.lintConfigHasOverride = lintConfigHasOverride;
+function replaceOverridesInLintConfig(tree, root, overrides) {
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, 'eslint.config.js');
+        let content = tree.read(fileName, 'utf8');
+        // we will be using compat here so we need to make sure it's added
+        if (overrides.some(overrideNeedsCompat)) {
+            content = (0, ast_utils_1.addCompatToFlatConfig)(content);
+        }
+        content = (0, ast_utils_1.removeOverridesFromLintConfig)(content);
+        overrides.forEach((override) => {
+            const flatOverride = (0, ast_utils_1.generateFlatOverride)(override);
+            (0, ast_utils_1.addBlockToFlatConfigExport)(content, flatOverride);
+        });
+        tree.write(fileName, content);
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, '.eslintrc.json');
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            json.overrides = overrides;
+            return json;
+        });
+    }
+}
+exports.replaceOverridesInLintConfig = replaceOverridesInLintConfig;
+function addExtendsToLintConfig(tree, root, plugin) {
+    const plugins = Array.isArray(plugin) ? plugin : [plugin];
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, 'eslint.config.js');
+        const pluginExtends = (0, ast_utils_1.generatePluginExtendsElement)(plugins);
+        let content = tree.read(fileName, 'utf8');
+        content = (0, ast_utils_1.addCompatToFlatConfig)(content);
+        tree.write(fileName, (0, ast_utils_1.addBlockToFlatConfigExport)(content, pluginExtends));
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, '.eslintrc.json');
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            json.extends ??= [];
+            json.extends = [
+                ...plugins,
+                ...(Array.isArray(json.extends) ? json.extends : [json.extends]),
+            ];
+            return json;
+        });
+    }
+}
+exports.addExtendsToLintConfig = addExtendsToLintConfig;
+function addPluginsToLintConfig(tree, root, plugin) {
+    const plugins = Array.isArray(plugin) ? plugin : [plugin];
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, 'eslint.config.js');
+        let content = tree.read(fileName, 'utf8');
+        const mappedPlugins = [];
+        plugins.forEach((name) => {
+            const imp = getPluginImport(name);
+            const varName = (0, devkit_1.names)(imp).propertyName;
+            mappedPlugins.push({ name, varName, imp });
+        });
+        mappedPlugins.forEach(({ varName, imp }) => {
+            content = (0, ast_utils_1.addImportToFlatConfig)(content, varName, imp);
+        });
+        content = (0, ast_utils_1.addPluginsToExportsBlock)(content, mappedPlugins);
+        tree.write(fileName, content);
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, '.eslintrc.json');
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            json.plugins = [...plugins, ...(json.plugins ?? [])];
+            return json;
+        });
+    }
+}
+exports.addPluginsToLintConfig = addPluginsToLintConfig;
+function addIgnoresToLintConfig(tree, root, ignorePatterns) {
+    if ((0, flat_config_1.useFlatConfig)(tree)) {
+        const fileName = (0, devkit_1.joinPathFragments)(root, 'eslint.config.js');
+        const block = (0, ast_utils_1.generateAst)({
+            ignores: ignorePatterns.map((path) => (0, path_utils_1.mapFilePath)(path)),
+        });
+        tree.write(fileName, (0, ast_utils_1.addBlockToFlatConfigExport)(tree.read(fileName, 'utf8'), block));
+    }
+    else {
+        const fileName = (0, devkit_1.joinPathFragments)(root, '.eslintrc.json');
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            const ignoreSet = new Set([
+                ...(json.ignorePatterns ?? []),
+                ...ignorePatterns,
+            ]);
+            json.ignorePatterns = Array.from(ignoreSet);
+            return json;
+        });
+    }
+}
+exports.addIgnoresToLintConfig = addIgnoresToLintConfig;
+function getPluginImport(pluginName) {
+    if (pluginName.includes('eslint-plugin-')) {
+        return pluginName;
+    }
+    if (!pluginName.startsWith('@')) {
+        return `eslint-plugin-${pluginName}`;
+    }
+    if (!pluginName.includes('/')) {
+        return `${pluginName}/eslint-plugin`;
+    }
+    const [scope, name] = pluginName.split('/');
+    return `${scope}/eslint-plugin-${name}`;
+}
+exports.getPluginImport = getPluginImport;

package/src/generators/utils/eslint-targets.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function getEslintTargets(tree: Tree): Set<string>;

package/src/generators/utils/eslint-targets.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEslintTargets = void 0;
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+function getEslintTargets(tree) {
+    const eslintTargetNames = new Set();
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/eslint:lint', (_, __, target) => {
+        eslintTargetNames.add(target);
+    });
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/linter:eslint', (_, __, target) => {
+        eslintTargetNames.add(target);
+    });
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/linter:eslint', (_, __, target) => {
+        eslintTargetNames.add(target);
+    });
+    return eslintTargetNames;
+}
+exports.getEslintTargets = getEslintTargets;

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

@@ -0,0 +1,60 @@
+import { Linter } from 'eslint';
+import * as ts from 'typescript';
+/**
+ * Remove all overrides from the config file
+ */
+export declare function removeOverridesFromLintConfig(content: string): string;
+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
+ */
+export declare function replaceOverride(content: string, root: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean, update?: (override: Linter.ConfigOverride<Linter.RulesRecord>) => Linter.ConfigOverride<Linter.RulesRecord>): string;
+/**
+ * Adding require statement to the top of the file
+ */
+export declare function addImportToFlatConfig(content: string, variable: string | string[], imp: string): string;
+/**
+ * Injects new ts.expression to the end of the module.exports array.
+ */
+export declare function addBlockToFlatConfigExport(content: string, config: ts.Expression | ts.SpreadElement, options?: {
+    insertAtTheEnd?: boolean;
+    checkBaseConfig?: boolean;
+}): string;
+export declare function removePlugin(content: string, pluginName: string, pluginImport: string): string;
+export declare function removeCompatExtends(content: string, compatExtends: string[]): string;
+/**
+ * Add plugins block to the top of the export blocks
+ */
+export declare function addPluginsToExportsBlock(content: string, plugins: {
+    name: string;
+    varName: string;
+    imp: string;
+}[]): string;
+/**
+ * Adds compat if missing to flat config
+ */
+export declare function addCompatToFlatConfig(content: string): string;
+/**
+ * Generate node list representing the imports and the exports blocks
+ * Optionally add flat compat initialization
+ */
+export declare function createNodeList(importsMap: Map<string, string>, exportElements: ts.Expression[], isFlatCompatNeeded: boolean): ts.NodeArray<ts.VariableStatement | ts.Identifier | ts.ExpressionStatement | ts.SourceFile>;
+export declare function generateSpreadElement(name: string): ts.SpreadElement;
+export declare function generatePluginExtendsElement(plugins: string[]): ts.SpreadElement;
+/**
+ * Stringifies TS nodes to file content string
+ */
+export declare function stringifyNodeList(nodes: ts.NodeArray<ts.VariableStatement | ts.Identifier | ts.ExpressionStatement | ts.SourceFile>): string;
+/**
+ * generates AST require statement
+ */
+export declare function generateRequire(variableName: string | ts.ObjectBindingPattern, imp: string): ts.VariableStatement;
+/**
+ * Generates AST object or spread element based on JSON override object
+ */
+export declare function generateFlatOverride(override: Linter.ConfigOverride<Linter.RulesRecord>): ts.ObjectLiteralExpression | ts.SpreadElement;
+export declare function mapFilePaths(override: Linter.ConfigOverride<Linter.RulesRecord>): void;
+/**
+ * Generates an AST from a JSON-type input
+ */
+export declare function generateAst<T>(input: unknown): T;