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

package/src/generators/workspace-rule/files/__name__.ts__tmpl__

@@ -0,0 +1,37 @@
+/**
+ * This file sets you up with structure needed for an ESLint rule.
+ *
+ * It leverages utilities from @typescript-eslint to allow TypeScript to
+ * provide autocompletions etc for the configuration.
+ *
+ * Your rule's custom logic will live within the create() method below
+ * and you can learn more about writing ESLint rules on the official guide:
+ *
+ * https://eslint.org/docs/developer-guide/working-with-rules
+ *
+ * You can also view many examples of existing rules here:
+ *
+ * https://github.com/typescript-eslint/typescript-eslint/tree/master/packages/eslint-plugin/src/rules
+ */
+
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+// NOTE: The rule will be available in ESLint configs as "@nx/workspace-<%= name %>"
+export const RULE_NAME = '<%= name %>';
+
+export const rule = ESLintUtils.RuleCreator(() => __filename)({
+  name: RULE_NAME,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: ``,
+      recommended: 'recommended',
+    },
+    schema: [],
+    messages: {},
+  },
+  defaultOptions: [],
+  create(context) {
+    return {};
+  },
+});

package/src/generators/workspace-rule/schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxWorkspaceRule",
+  "cli": "nx",
+  "title": "Create a new Workspace Lint Rule",
+  "description": "Create a new Workspace Lint Rule.",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the new rule.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      }
+    },
+    "directory": {
+      "type": "string",
+      "description": "Create the rule under this directory within `tools/eslint-rules/` (can be nested).",
+      "alias": "dir",
+      "default": "rules"
+    }
+  },
+  "required": ["name", "directory"],
+  "examplesFile": "../../../docs/workspace-rule-examples.md"
+}

package/src/generators/workspace-rule/workspace-rule.d.ts

@@ -0,0 +1,6 @@
+import { Tree } from '@nx/devkit';
+export interface LintWorkspaceRuleGeneratorOptions {
+    name: string;
+    directory: string;
+}
+export declare function lintWorkspaceRuleGenerator(tree: Tree, options: LintWorkspaceRuleGeneratorOptions): Promise<import("@nx/devkit").GeneratorCallback>;

package/src/generators/workspace-rule/workspace-rule.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintWorkspaceRuleGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const string_utils_1 = require("@nx/devkit/src/utils/string-utils");
+const path_1 = require("path");
+const ts = require("typescript");
+const workspace_lint_rules_1 = require("../../utils/workspace-lint-rules");
+const workspace_rules_project_1 = require("../workspace-rules-project/workspace-rules-project");
+async function lintWorkspaceRuleGenerator(tree, options) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    // Ensure that the workspace rules project has been created
+    const projectGeneratorCallback = await (0, workspace_rules_project_1.lintWorkspaceRulesProjectGenerator)(tree, {
+        skipFormat: true,
+        addPlugin: process.env.NX_ADD_PLUGINS !== 'false' &&
+            nxJson.useInferencePlugins !== false,
+    });
+    const ruleDir = (0, devkit_1.joinPathFragments)(workspace_lint_rules_1.workspaceLintPluginDir, options.directory ?? '');
+    // Generate the required files for the new rule
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, 'files'), ruleDir, {
+        tmpl: '',
+        name: options.name,
+    });
+    const nameCamelCase = (0, string_utils_1.camelize)(options.name);
+    /**
+     * Import the new rule into the workspace plugin index.ts and
+     * register it ready for use in lint configs.
+     */
+    const pluginIndexPath = (0, devkit_1.joinPathFragments)(workspace_lint_rules_1.workspaceLintPluginDir, 'index.ts');
+    const existingPluginIndexContents = tree.read(pluginIndexPath, 'utf-8');
+    const pluginIndexSourceFile = ts.createSourceFile(pluginIndexPath, existingPluginIndexContents, ts.ScriptTarget.Latest, true);
+    function findRulesObject(node) {
+        if (ts.isPropertyAssignment(node) &&
+            ts.isIdentifier(node.name) &&
+            node.name.text === 'rules' &&
+            ts.isObjectLiteralExpression(node.initializer)) {
+            return node.initializer;
+        }
+        return node.forEachChild(findRulesObject);
+    }
+    const rulesObject = pluginIndexSourceFile.forEachChild((node) => findRulesObject(node));
+    if (rulesObject) {
+        const ruleNameSymbol = `${nameCamelCase}Name`;
+        const ruleConfigSymbol = nameCamelCase;
+        /**
+         * If the rules object already has entries, we need to make sure our insertion
+         * takes commas into account.
+         */
+        let leadingComma = '';
+        if (rulesObject.properties.length > 0) {
+            if (!rulesObject.properties.hasTrailingComma) {
+                leadingComma = ',';
+            }
+        }
+        const newContents = (0, devkit_1.applyChangesToString)(existingPluginIndexContents, [
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: 0,
+                text: `import { RULE_NAME as ${ruleNameSymbol}, rule as ${ruleConfigSymbol} } from './${options.directory ? `${options.directory}/` : ''}${options.name}';\n`,
+            },
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: rulesObject.getEnd() - 1,
+                text: `${leadingComma}[${ruleNameSymbol}]: ${ruleConfigSymbol}\n`,
+            },
+        ]);
+        tree.write(pluginIndexPath, newContents);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+    devkit_1.logger.info(`NX Reminder: Once you have finished writing your rule logic, you need to actually enable the rule within an appropriate ESLint config in your workspace, for example:
+
+       "rules": {
+         "@nx/workspace-${options.name}": "error"
+       }
+`);
+    return projectGeneratorCallback;
+}
+exports.lintWorkspaceRuleGenerator = lintWorkspaceRuleGenerator;

package/src/generators/workspace-rules-project/files/index.ts__tmpl__

@@ -0,0 +1,27 @@
+/**
+ * Import your custom workspace rules at the top of this file.
+ *
+ * For example:
+ *
+ * import { RULE_NAME as myCustomRuleName, rule as myCustomRule } from './rules/my-custom-rule';
+ *
+ * In order to quickly get started with writing rules you can use the
+ * following generator command and provide your desired rule name:
+ *
+ * ```sh
+ * npx nx g @nx/eslint:workspace-rule {{ NEW_RULE_NAME }}
+ * ```
+ */
+
+module.exports = {
+  /**
+   * Apply the imported custom rules here.
+   *
+   * For example (using the example import above):
+   *
+   * rules: {
+   *  [myCustomRuleName]: myCustomRule
+   * }
+   */
+  rules: {}
+};

package/src/generators/workspace-rules-project/files/tsconfig.json__tmpl__

@@ -0,0 +1,14 @@
+{
+  "extends": "<%= rootTsConfigPath %>",
+  "compilerOptions": {
+    "moduleResolution": "node16",
+    "module": "node16"
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lint.json"
+    }
+  ]
+}

package/src/generators/workspace-rules-project/files/tsconfig.lint.json__tmpl__

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "<%= offsetFromRoot %>dist/out-tsc",
+    "types": ["node"]
+  },
+  "exclude": ["**/*.spec.ts"],
+  "include": ["**/*.ts"]
+}

package/src/generators/workspace-rules-project/schema.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxWorkspaceRulesProject",
+  "cli": "nx",
+  "title": "Create the Workspace Lint Rules Project",
+  "description": "Create the Workspace Lint Rules Project.",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g @nx/eslint:workspace-rules-project",
+      "description": "Create the Workspace Lint Rules Project"
+    }
+  ],
+  "properties": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    }
+  },
+  "required": []
+}

package/src/generators/workspace-rules-project/workspace-rules-project.d.ts

@@ -0,0 +1,8 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+export declare const WORKSPACE_RULES_PROJECT_NAME = "eslint-rules";
+export declare const WORKSPACE_PLUGIN_DIR = "tools/eslint-rules";
+export interface LintWorkspaceRulesProjectGeneratorOptions {
+    skipFormat?: boolean;
+    addPlugin?: boolean;
+}
+export declare function lintWorkspaceRulesProjectGenerator(tree: Tree, options?: LintWorkspaceRulesProjectGeneratorOptions): Promise<GeneratorCallback>;

package/src/generators/workspace-rules-project/workspace-rules-project.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintWorkspaceRulesProjectGenerator = exports.WORKSPACE_PLUGIN_DIR = exports.WORKSPACE_RULES_PROJECT_NAME = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const add_swc_dependencies_1 = require("@nx/js/src/utils/swc/add-swc-dependencies");
+const path_1 = require("path");
+const versions_1 = require("../../utils/versions");
+const workspace_lint_rules_1 = require("../../utils/workspace-lint-rules");
+exports.WORKSPACE_RULES_PROJECT_NAME = 'eslint-rules';
+exports.WORKSPACE_PLUGIN_DIR = 'tools/eslint-rules';
+async function lintWorkspaceRulesProjectGenerator(tree, options = {}) {
+    const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
+    const tasks = [];
+    // Noop if the workspace rules project already exists
+    try {
+        (0, devkit_1.readProjectConfiguration)(tree, exports.WORKSPACE_RULES_PROJECT_NAME);
+        return;
+    }
+    catch { }
+    // Create the project, the test target is added below by the jest generator
+    (0, devkit_1.addProjectConfiguration)(tree, exports.WORKSPACE_RULES_PROJECT_NAME, {
+        root: exports.WORKSPACE_PLUGIN_DIR,
+        sourceRoot: exports.WORKSPACE_PLUGIN_DIR,
+        targets: {},
+    });
+    // Generate the required files
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, 'files'), workspace_lint_rules_1.workspaceLintPluginDir, {
+        tmpl: '',
+        offsetFromRoot: (0, devkit_1.offsetFromRoot)(exports.WORKSPACE_PLUGIN_DIR),
+        rootTsConfigPath: (0, js_1.getRelativePathToRootTsConfig)(tree, exports.WORKSPACE_PLUGIN_DIR),
+    });
+    /**
+     * Ensure that when workspace rules are updated they cause all projects to be affected for now.
+     * TODO: Explore writing a ProjectGraph plugin to make this more surgical.
+     */
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (nxJson.targetDefaults?.lint?.inputs) {
+        nxJson.targetDefaults.lint.inputs.push(`{workspaceRoot}/${exports.WORKSPACE_PLUGIN_DIR}/**/*`);
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+    // Add jest to the project and return installation task
+    tasks.push(await configurationGenerator(tree, {
+        ...options,
+        project: exports.WORKSPACE_RULES_PROJECT_NAME,
+        supportTsx: false,
+        skipSerializers: true,
+        setupFile: 'none',
+        compiler: 'tsc',
+        skipFormat: true,
+    }));
+    (0, devkit_1.updateJson)(tree, (0, path_1.join)(workspace_lint_rules_1.workspaceLintPluginDir, 'tsconfig.spec.json'), (json) => {
+        delete json.compilerOptions?.module;
+        if (json.include) {
+            json.include = json.include.map((v) => {
+                if (v.startsWith('src/**')) {
+                    return v.replace('src/', '');
+                }
+                return v;
+            });
+        }
+        if (json.exclude) {
+            json.exclude = json.exclude.map((v) => {
+                if (v.startsWith('src/**')) {
+                    return v.replace('src/', '');
+                }
+                return v;
+            });
+        }
+        return json;
+    });
+    // Add swc dependencies
+    tasks.push((0, add_swc_dependencies_1.addSwcRegisterDependencies)(tree));
+    tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        '@typescript-eslint/utils': versions_1.typescriptESLintVersion,
+    }));
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.lintWorkspaceRulesProjectGenerator = lintWorkspaceRulesProjectGenerator;

package/src/migrations/update-15-0-0/add-eslint-inputs.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function addEslintInputs(tree: Tree): Promise<void>;

package/src/migrations/update-15-0-0/add-eslint-inputs.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const eslint_targets_1 = require("../../generators/utils/eslint-targets");
+const config_file_1 = require("../../utils/config-file");
+async function addEslintInputs(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const globalEslintFile = config_file_1.ESLINT_CONFIG_FILENAMES.find((file) => tree.exists(file));
+    if (globalEslintFile && nxJson.namedInputs?.production) {
+        const productionFileset = new Set(nxJson.namedInputs.production);
+        productionFileset.add(`!{projectRoot}/${globalEslintFile}`);
+        nxJson.namedInputs.production = Array.from(productionFileset);
+    }
+    for (const targetName of (0, eslint_targets_1.getEslintTargets)(tree)) {
+        nxJson.targetDefaults ??= {};
+        const lintTargetDefaults = (nxJson.targetDefaults[targetName] ??= {});
+        lintTargetDefaults.inputs ??= [
+            'default',
+            ...(globalEslintFile
+                ? [(0, devkit_1.joinPathFragments)('{workspaceRoot}', globalEslintFile)]
+                : []),
+        ];
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = addEslintInputs;

package/src/migrations/update-15-7-1/add-eslint-ignore.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function addEslintIgnore(tree: Tree): Promise<void>;

package/src/migrations/update-15-7-1/add-eslint-ignore.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const eslint_targets_1 = require("../../generators/utils/eslint-targets");
+const config_file_1 = require("../../utils/config-file");
+async function addEslintIgnore(tree) {
+    const nxJson = (0, devkit_1.readJson)(tree, 'nx.json');
+    const globalEslintFile = config_file_1.ESLINT_CONFIG_FILENAMES.find((file) => tree.exists(file));
+    if (globalEslintFile) {
+        if (tree.exists('.eslintignore')) {
+            const content = tree.read('.eslintignore', 'utf-8');
+            if (!content.includes('node_modules')) {
+                tree.write('.eslintignore', `node_modules\n${content}`);
+            }
+        }
+        else {
+            tree.write('.eslintignore', 'node_modules\n');
+        }
+        for (const targetName of (0, eslint_targets_1.getEslintTargets)(tree)) {
+            nxJson.targetDefaults ??= {};
+            const lintTargetDefaults = (nxJson.targetDefaults[targetName] ??= {});
+            const lintIgnorePath = (0, devkit_1.joinPathFragments)('{workspaceRoot}', globalEslintFile);
+            if (lintTargetDefaults.inputs) {
+                if (!lintTargetDefaults.inputs.includes(lintIgnorePath)) {
+                    lintTargetDefaults.inputs.push(lintIgnorePath);
+                }
+            }
+            else {
+                lintTargetDefaults.inputs = ['default', lintIgnorePath];
+            }
+        }
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.default = addEslintIgnore;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function replacePackage(tree: Tree): Promise<void>;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
+async function replacePackage(tree) {
+    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nrwl/linter', '@nx/linter');
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = replacePackage;

package/src/migrations/update-16-8-0-add-ignored-files/update-16-8-0-add-ignored-files.d.ts

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

package/src/migrations/update-16-8-0-add-ignored-files/update-16-8-0-add-ignored-files.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const eslint_file_1 = require("../../generators/utils/eslint-file");
+// Add `ignoredFiles` pattern to projects using vite, esbuild, and rollup.
+// This is needed because the @nx/dependency-checks lint rule will complain
+// about dependencies used in build config files, even though they are not
+// production dependencies.
+function update(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    const addIgnorePattern = (ignorePattern) => (_options, projectName) => {
+        const project = projects.get(projectName);
+        if (!(0, eslint_file_1.findEslintFile)(tree, project.root) ||
+            !(0, eslint_file_1.isEslintConfigSupported)(tree)) {
+            return;
+        }
+        if ((0, eslint_file_1.lintConfigHasOverride)(tree, project.root, (o) => Array.isArray(o.files)
+            ? o.files.some((f) => f.match(/\.json$/))
+            : !!o.files?.match(/\.json$/), true)) {
+            (0, eslint_file_1.updateOverrideInLintConfig)(tree, project.root, (o) => !!o.rules?.['@nx/dependency-checks'], (o) => {
+                const value = o.rules['@nx/dependency-checks'];
+                let ruleSeverity;
+                let ruleOptions;
+                if (Array.isArray(value)) {
+                    ruleSeverity = value[0];
+                    ruleOptions = value[1];
+                }
+                else {
+                    ruleSeverity = value;
+                    ruleOptions = {};
+                }
+                ruleOptions.ignoredFiles = [ignorePattern];
+                o.rules['@nx/dependency-checks'] = [ruleSeverity, ruleOptions];
+                return o;
+            });
+        }
+    };
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/vite:build', addIgnorePattern('{projectRoot}/vite.config.{js,ts,mjs,mts}'));
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/vite:test', addIgnorePattern('{projectRoot}/vite.config.{js,ts,mjs,mts}'));
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/esbuild:esbuild', addIgnorePattern('{projectRoot}/esbuild.config.{js,ts,mjs,mts}'));
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/rollup:rollup', addIgnorePattern('{projectRoot}/rollup.config.{js,ts,mjs,mts}'));
+}
+exports.default = update;

package/src/migrations/update-17-0-0-rename-to-eslint/update-17-0-0-rename-to-eslint.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function replacePackage(tree: Tree): Promise<void>;

package/src/migrations/update-17-0-0-rename-to-eslint/update-17-0-0-rename-to-eslint.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
+async function replacePackage(tree) {
+    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nx/linter', '@nx/eslint');
+    // executor name change from :eslint to :lint
+    updateNxJsonExecutor(tree);
+    updateProjectExecutor(tree);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = replacePackage;
+function updateNxJsonExecutor(tree) {
+    if (!tree.exists('nx.json')) {
+        return;
+    }
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    let needsUpdate = false;
+    for (const [targetName, targetConfig] of Object.entries(nxJson.targetDefaults ?? {})) {
+        // this will be in a broken state after the package is globally renamed
+        if (targetConfig.executor !== '@nx/eslint:eslint') {
+            continue;
+        }
+        needsUpdate = true;
+        nxJson.targetDefaults[targetName].executor = '@nx/eslint:lint';
+    }
+    if (needsUpdate) {
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+}
+function updateProjectExecutor(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const [projectName, projectConfiguration] of projects) {
+        let needsUpdate = false;
+        for (const [targetName, targetConfig] of Object.entries(projectConfiguration.targets ?? {})) {
+            // this will be in a broken state after the package is globally renamed
+            if (targetConfig.executor !== '@nx/eslint:eslint') {
+                continue;
+            }
+            needsUpdate = true;
+            projectConfiguration.targets[targetName].executor = '@nx/eslint:lint';
+        }
+        if (needsUpdate) {
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+        }
+    }
+}

package/src/migrations/update-17-1-0/update-typescript-eslint.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;

package/src/migrations/update-17-1-0/update-typescript-eslint.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../utils/versions");
+const path_1 = require("path");
+const typescript_1 = require("typescript");
+function updateJestConfig(tree) {
+    const jestConfigPath = 'tools/eslint-rules/jest.config.ts';
+    if (tree.exists(jestConfigPath)) {
+        const { removePropertyFromJestConfig } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
+        removePropertyFromJestConfig(tree, jestConfigPath, [
+            'moduleNameMapper',
+            '@eslint/eslintrc',
+        ]);
+    }
+}
+function updateTsConfigs(tree) {
+    const tsConfigPath = 'tools/eslint-rules/tsconfig.json';
+    if (tree.exists(tsConfigPath)) {
+        (0, devkit_1.updateJson)(tree, tsConfigPath, (tsConfig) => {
+            tsConfig.compilerOptions ??= {};
+            tsConfig.compilerOptions.moduleResolution = 'node16';
+            tsConfig.compilerOptions.module = 'node16';
+            return tsConfig;
+        });
+    }
+    const tsConfigSpec = 'tools/eslint-rules/tsconfig.spec.json';
+    if (tree.exists(tsConfigSpec)) {
+        (0, devkit_1.updateJson)(tree, tsConfigSpec, (tsConfigSpec) => {
+            delete tsConfigSpec.compilerOptions?.module;
+            delete tsConfigSpec.compilerOptions?.moduleResolution;
+            return tsConfigSpec;
+        });
+    }
+}
+function updateRecommended(tree) {
+    (0, devkit_1.visitNotIgnoredFiles)(tree, 'tools/eslint-rules', (path) => {
+        if ((0, path_1.extname)(path) !== '.ts') {
+            return;
+        }
+        const contents = tree.read(path, 'utf-8');
+        const sourceFile = (0, typescript_1.createSourceFile)(path, contents, typescript_1.ScriptTarget.ESNext, true);
+        const changes = [];
+        const visit = (node) => {
+            if ((0, typescript_1.isPropertyAssignment)(node) &&
+                (0, typescript_1.isIdentifier)(node.name) &&
+                node.name.text === 'recommended' &&
+                (0, typescript_1.isStringLiteral)(node.initializer)) {
+                changes.push({
+                    type: devkit_1.ChangeType.Delete,
+                    start: node.initializer.getStart(sourceFile),
+                    length: node.initializer.getWidth(sourceFile),
+                });
+                changes.push({
+                    type: devkit_1.ChangeType.Insert,
+                    index: node.initializer.getStart(sourceFile),
+                    text: "'recommended'",
+                });
+            }
+            else {
+                (0, typescript_1.forEachChild)(node, visit);
+            }
+        };
+        (0, typescript_1.forEachChild)(sourceFile, visit);
+        tree.write(path, (0, devkit_1.applyChangesToString)(contents, changes));
+    });
+}
+async function update(tree) {
+    updateJestConfig(tree);
+    updateTsConfigs(tree);
+    updateRecommended(tree);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = update;

package/src/migrations/update-17-2-0/simplify-eslint-patterns.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;

package/src/migrations/update-17-2-0/simplify-eslint-patterns.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+async function update(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const [projectName, projectConfiguration] of projects) {
+        let needsUpdate = false;
+        for (const [targetName, targetConfig] of Object.entries(projectConfiguration.targets ?? {})) {
+            if (targetConfig.executor !== '@nx/eslint:lint') {
+                continue;
+            }
+            needsUpdate = true;
+            if (projectConfiguration.targets[targetName].options?.lintFilePatterns) {
+                const rootPattern = getLintRoot(projectConfiguration);
+                const nonRootPatterns = projectConfiguration.targets[targetName].options.lintFilePatterns.filter((p) => !p.startsWith(rootPattern) && !p.startsWith('{projectRoot}'));
+                if (nonRootPatterns.length === 0 &&
+                    rootPattern === projectConfiguration.root) {
+                    // delete the lintFilePatterns option if it's the only option and matches the root of the project
+                    delete projectConfiguration.targets[targetName].options
+                        .lintFilePatterns;
+                    if (Object.keys(projectConfiguration.targets[targetName].options)
+                        .length === 0) {
+                        delete projectConfiguration.targets[targetName].options;
+                    }
+                }
+                else {
+                    projectConfiguration.targets[targetName].options.lintFilePatterns = [
+                        rootPattern,
+                        ...nonRootPatterns,
+                    ];
+                }
+            }
+        }
+        if (needsUpdate) {
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = update;
+function getLintRoot({ root, sourceRoot }) {
+    if (root === '' || root === '.') {
+        return sourceRoot || './src';
+    }
+    return root;
+}

package/src/migrations/update-17-2-9/move-options-to-target-defaults.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;