@nx/eslint 17.0.0-beta.8

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

@@ -0,0 +1,26 @@
+{
+  "$schema": "http://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,73 @@
+"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) {
+    // Ensure that the workspace rules project has been created
+    const projectGeneratorCallback = await (0, workspace_rules_project_1.lintWorkspaceRulesProjectGenerator)(tree, { skipFormat: true });
+    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,13 @@
+{
+  "extends": "<%= rootTsConfigPath %>",
+  "compilerOptions": {
+    "module": "commonjs"
+  },
+  "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": "http://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,7 @@
+import { 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;
+}
+export declare function lintWorkspaceRulesProjectGenerator(tree: Tree, options?: LintWorkspaceRulesProjectGeneratorOptions): Promise<import("@nx/devkit").GeneratorCallback>;

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

@@ -0,0 +1,80 @@
+"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 { addPropertyToJestConfig, configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
+    // 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
+    const installTask = await configurationGenerator(tree, {
+        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) => {
+        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
+    (0, add_swc_dependencies_1.addSwcRegisterDependencies)(tree);
+    // Add extra config to the jest.config.ts file to allow ESLint 8 exports mapping to work with jest
+    addPropertyToJestConfig(tree, (0, devkit_1.joinPathFragments)(exports.WORKSPACE_PLUGIN_DIR, 'jest.config.ts'), 'moduleNameMapper', {
+        '@eslint/eslintrc': '@eslint/eslintrc/dist/eslintrc-universal.cjs',
+    });
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return installTask;
+}
+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_file_1 = require("../../generators/utils/eslint-file");
+const eslint_targets_1 = require("../../generators/utils/eslint-targets");
+async function addEslintInputs(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const globalEslintFile = eslint_file_1.eslintConfigFileWhitelist.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_file_1 = require("../../generators/utils/eslint-file");
+const eslint_targets_1 = require("../../generators/utils/eslint-targets");
+async function addEslintIgnore(tree) {
+    const nxJson = (0, devkit_1.readJson)(tree, 'nx.json');
+    const globalEslintFile = eslint_file_1.eslintConfigFileWhitelist.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,45 @@
+"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 ?? {})) {
+        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 ?? {})) {
+            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/utils/flat-config.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function useFlatConfig(tree: Tree): boolean;

package/src/utils/flat-config.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFlatConfig = void 0;
+function useFlatConfig(tree) {
+    return tree.exists('eslint.config.js');
+}
+exports.useFlatConfig = useFlatConfig;

package/src/utils/rules-requiring-type-checking.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from 'eslint';
+export declare function hasRulesRequiringTypeChecking(eslintConfig: Linter.Config): boolean;
+export declare function removeParserOptionsProjectIfNotRequired(json: Linter.Config): Linter.Config;

package/src/utils/rules-requiring-type-checking.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeParserOptionsProjectIfNotRequired = exports.hasRulesRequiringTypeChecking = void 0;
+// Cache the resolved rules from node_modules
+let knownRulesRequiringTypeChecking = null;
+function resolveKnownRulesRequiringTypeChecking() {
+    if (knownRulesRequiringTypeChecking) {
+        return knownRulesRequiringTypeChecking;
+    }
+    try {
+        const { rules } = require('@typescript-eslint/eslint-plugin');
+        const rulesRequiringTypeInfo = Object.entries(rules)
+            .map(([ruleName, config]) => {
+            if (config.meta?.docs?.requiresTypeChecking) {
+                return `@typescript-eslint/${ruleName}`;
+            }
+            return null;
+        })
+            .filter(Boolean);
+        return rulesRequiringTypeInfo;
+    }
+    catch (err) {
+        console.log(err);
+        return null;
+    }
+}
+function hasRulesRequiringTypeChecking(eslintConfig) {
+    knownRulesRequiringTypeChecking = resolveKnownRulesRequiringTypeChecking();
+    if (!knownRulesRequiringTypeChecking) {
+        /**
+         * If (unexpectedly) known rules requiring type checking could not be resolved,
+         * default to assuming that the rules are in use to align most closely with Nx
+         * ESLint configs to date.
+         */
+        return true;
+    }
+    const allRulesInConfig = getAllRulesInConfig(eslintConfig);
+    return allRulesInConfig.some((rule) => knownRulesRequiringTypeChecking.includes(rule));
+}
+exports.hasRulesRequiringTypeChecking = hasRulesRequiringTypeChecking;
+function removeParserOptionsProjectIfNotRequired(json) {
+    // At least one rule requiring type-checking is in use, do not migrate the config
+    if (hasRulesRequiringTypeChecking(json)) {
+        return json;
+    }
+    removeProjectParserOptionFromConfig(json);
+    return json;
+}
+exports.removeParserOptionsProjectIfNotRequired = removeParserOptionsProjectIfNotRequired;
+function determineEnabledRules(rules) {
+    return Object.entries(rules)
+        .filter(([key, value]) => {
+        return !(typeof value === 'string' && value === 'off');
+    })
+        .map(([ruleName]) => ruleName);
+}
+function getAllRulesInConfig(json) {
+    let allRules = json.rules ? determineEnabledRules(json.rules) : [];
+    if (json.overrides?.length > 0) {
+        for (const o of json.overrides) {
+            if (o.rules) {
+                allRules = allRules = [...allRules, ...determineEnabledRules(o.rules)];
+            }
+        }
+    }
+    return allRules;
+}
+function removeProjectParserOptionFromConfig(json) {
+    delete json.parserOptions?.project;
+    // If parserOptions is left empty by this removal, also clean up the whole object
+    if (json.parserOptions && Object.keys(json.parserOptions).length === 0) {
+        delete json.parserOptions;
+    }
+    if (json.overrides) {
+        for (const override of json.overrides) {
+            delete override.parserOptions?.project;
+            // If parserOptions is left empty by this removal, also clean up the whole object
+            if (override.parserOptions &&
+                Object.keys(override.parserOptions).length === 0) {
+                delete override.parserOptions;
+            }
+        }
+    }
+}

package/src/utils/versions.d.ts

@@ -0,0 +1,5 @@
+export declare const nxVersion: any;
+export declare const eslintVersion = "~8.46.0";
+export declare const eslintrcVersion = "^2.1.1";
+export declare const eslintConfigPrettierVersion = "9.0.0";
+export declare const typescriptESLintVersion = "^5.60.1";

package/src/utils/versions.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescriptESLintVersion = exports.eslintConfigPrettierVersion = exports.eslintrcVersion = exports.eslintVersion = exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;
+exports.eslintVersion = '~8.46.0';
+exports.eslintrcVersion = '^2.1.1';
+exports.eslintConfigPrettierVersion = '9.0.0';
+exports.typescriptESLintVersion = '^5.60.1';

package/src/utils/workspace-lint-rules.d.ts

@@ -0,0 +1 @@
+export declare const workspaceLintPluginDir: string;

package/src/utils/workspace-lint-rules.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceLintPluginDir = void 0;
+const devkit_1 = require("@nx/devkit");
+exports.workspaceLintPluginDir = (0, devkit_1.joinPathFragments)('tools/eslint-rules');