@nx/js 23.2.0-beta.6 → 23.2.0-beta.7

package/dist/internal.d.ts

@@ -21,6 +21,8 @@ export { getProjectPackageManagerWorkspaceState, getProjectPackageManagerWorkspa
 export { findNpmDependencies } from './src/utils/find-npm-dependencies';
 export { addBuildAndWatchDepsTargets, isValidPackageJsonBuildConfig, } from './src/plugins/typescript/util';
 export { normalizeLinterOption, normalizeUnitTestRunnerOption, } from './src/utils/generator-prompts';
+export { detectLinters } from './src/utils/linter';
+export { addLintingToProject, type AddLintingToProjectOptions, } from './src/utils/add-linting-to-project';
 export { createGlobPatternsForDependencies } from './src/utils/generate-globs';
 export { getImportPath } from './src/utils/get-import-path';
 export { stripGlobToBaseDir } from './src/utils/strip-glob-to-base-dir';

package/dist/internal.js

@@ -5,8 +5,8 @@
 // internal consumers and may change without semver protection. Consider it
 // the @nx/js equivalent of `@nx/devkit/internal`.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addLocalRegistryScripts = exports.stripGlobToBaseDir = exports.getImportPath = exports.createGlobPatternsForDependencies = exports.normalizeUnitTestRunnerOption = exports.normalizeLinterOption = exports.isValidPackageJsonBuildConfig = exports.addBuildAndWatchDepsTargets = exports.findNpmDependencies = exports.getProjectPackageManagerWorkspaceStateWarningTask = exports.getProjectPackageManagerWorkspaceState = exports.getNpmScope = exports.sortPackageJsonFields = exports.CopyAssetsHandler = exports.addSwcRegisterDependencies = exports.addSwcDependencies = exports.addSwcTestConfig = exports.addSwcConfig = exports.createTmpTsConfig = exports.computeCompilerOptionsPaths = exports.calculateProjectDependencies = exports.calculateProjectBuildableDependencies = exports.compileTypeScript = exports.getNeededCompilerOptionOverrides = exports.isTypescriptVersionAtLeast = exports.getTsConfigModuleResolution = exports.getRangeMinimum = exports.ensureTypescript = exports.createTreeParseConfigHost = exports.getTsConfigBaseOptions = exports.updateTsconfigFiles = exports.shouldConfigureTsSolutionSetup = exports.isUsingTsSolutionSetup = exports.getProjectType = exports.getProjectSourceRoot = exports.getDefinedCustomConditionName = exports.findRuntimeTsConfigName = exports.assertNotUsingTsSolutionSetup = exports.addProjectToTsSolutionWorkspace = exports.TS_SOLUTION_SETUP_TSCONFIG_INPUT = exports.isEsmProject = exports.walkTsconfigExtendsChain = exports.findProjectsNpmDependencies = exports.isBuiltinModuleImport = exports.TargetProjectLocator = exports.requireWithTsconfigFallback = exports.registerTsConfigPaths = exports.registerTsProject = exports.loadTsFile = exports.forceRegisterEsmLoader = void 0;
-exports.typesNodeVersion = exports.tsLibVersion = exports.swcNodeVersion = exports.swcHelpersVersion = exports.swcCoreVersion = exports.swcCliVersion = exports.prettierVersion = exports.esbuildVersion = exports.nxVersion = exports.releaseTasks = exports.addReleaseConfigForTsSolution = exports.addReleaseConfigForNonTsSolution = void 0;
+exports.getImportPath = exports.createGlobPatternsForDependencies = exports.addLintingToProject = exports.detectLinters = exports.normalizeUnitTestRunnerOption = exports.normalizeLinterOption = exports.isValidPackageJsonBuildConfig = exports.addBuildAndWatchDepsTargets = exports.findNpmDependencies = exports.getProjectPackageManagerWorkspaceStateWarningTask = exports.getProjectPackageManagerWorkspaceState = exports.getNpmScope = exports.sortPackageJsonFields = exports.CopyAssetsHandler = exports.addSwcRegisterDependencies = exports.addSwcDependencies = exports.addSwcTestConfig = exports.addSwcConfig = exports.createTmpTsConfig = exports.computeCompilerOptionsPaths = exports.calculateProjectDependencies = exports.calculateProjectBuildableDependencies = exports.compileTypeScript = exports.getNeededCompilerOptionOverrides = exports.isTypescriptVersionAtLeast = exports.getTsConfigModuleResolution = exports.getRangeMinimum = exports.ensureTypescript = exports.createTreeParseConfigHost = exports.getTsConfigBaseOptions = exports.updateTsconfigFiles = exports.shouldConfigureTsSolutionSetup = exports.isUsingTsSolutionSetup = exports.getProjectType = exports.getProjectSourceRoot = exports.getDefinedCustomConditionName = exports.findRuntimeTsConfigName = exports.assertNotUsingTsSolutionSetup = exports.addProjectToTsSolutionWorkspace = exports.TS_SOLUTION_SETUP_TSCONFIG_INPUT = exports.isEsmProject = exports.walkTsconfigExtendsChain = exports.findProjectsNpmDependencies = exports.isBuiltinModuleImport = exports.TargetProjectLocator = exports.requireWithTsconfigFallback = exports.registerTsConfigPaths = exports.registerTsProject = exports.loadTsFile = exports.forceRegisterEsmLoader = void 0;
+exports.typesNodeVersion = exports.tsLibVersion = exports.swcNodeVersion = exports.swcHelpersVersion = exports.swcCoreVersion = exports.swcCliVersion = exports.prettierVersion = exports.esbuildVersion = exports.nxVersion = exports.releaseTasks = exports.addReleaseConfigForTsSolution = exports.addReleaseConfigForNonTsSolution = exports.addLocalRegistryScripts = exports.stripGlobToBaseDir = void 0;
 // Re-exports of nx-source internals.
 var internal_1 = require("@nx/devkit/internal");
 Object.defineProperty(exports, "forceRegisterEsmLoader", { enumerable: true, get: function () { return internal_1.forceRegisterEsmLoader; } });
@@ -89,6 +89,10 @@ Object.defineProperty(exports, "isValidPackageJsonBuildConfig", { enumerable: tr
 var generator_prompts_1 = require("./src/utils/generator-prompts");
 Object.defineProperty(exports, "normalizeLinterOption", { enumerable: true, get: function () { return generator_prompts_1.normalizeLinterOption; } });
 Object.defineProperty(exports, "normalizeUnitTestRunnerOption", { enumerable: true, get: function () { return generator_prompts_1.normalizeUnitTestRunnerOption; } });
+var linter_1 = require("./src/utils/linter");
+Object.defineProperty(exports, "detectLinters", { enumerable: true, get: function () { return linter_1.detectLinters; } });
+var add_linting_to_project_1 = require("./src/utils/add-linting-to-project");
+Object.defineProperty(exports, "addLintingToProject", { enumerable: true, get: function () { return add_linting_to_project_1.addLintingToProject; } });
 var generate_globs_1 = require("./src/utils/generate-globs");
 Object.defineProperty(exports, "createGlobPatternsForDependencies", { enumerable: true, get: function () { return generate_globs_1.createGlobPatternsForDependencies; } });
 var get_import_path_1 = require("./src/utils/get-import-path");

package/dist/src/generators/library/library.js

@@ -7,6 +7,7 @@ const tslib_1 = require("tslib");
 const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const path_1 = require("path");
+const add_linting_to_project_1 = require("../../utils/add-linting-to-project");
 const assert_supported_typescript_version_1 = require("../../utils/assert-supported-typescript-version");
 const generator_prompts_1 = require("../../utils/generator-prompts");
 const sort_fields_1 = require("../../utils/package-json/sort-fields");
@@ -248,6 +249,17 @@ async function configureProject(tree, options) {
     }
 }
 async function addLint(tree, options) {
+    // Everything below reaches into `@nx/eslint`'s config utilities, which have
+    // no equivalent for other linters. Dispatch before touching any of it.
+    if (options.linter !== 'eslint') {
+        return (0, add_linting_to_project_1.addLintingToProject)(tree, {
+            linter: options.linter,
+            project: options.name,
+            addPlugin: options.addPlugin,
+            rootProject: options.rootProject,
+            unitTestRunner: options.unitTestRunner,
+        });
+    }
     const { lintProjectGenerator } = (0, devkit_1.ensurePackage)('@nx/eslint', versions_1.nxVersion);
     const { addOverrideToLintConfig, lintConfigHasOverride, isEslintConfigSupported, updateOverrideInLintConfig, addIgnoresToLintConfig, isTypedLintingEnabled,
     // nx-ignore-next-line
@@ -638,6 +650,10 @@ async function normalizeOptions(tree, options) {
         isUsingTsSolutionConfig;
     return {
         ...options,
+        // Read from `options`, not a hoisted local: the `npm-scripts` block resets
+        // it to 'none' after `normalizeLinterOption` runs. Naming the key also
+        // satisfies the normalized type, since the spread carries `linter?`.
+        linter: options.linter,
         fileName,
         name: isUsingTsSolutionConfig && !options.name ? importPath : projectName,
         projectNames,

package/dist/src/generators/library/schema.d.ts

@@ -1,6 +1,5 @@
 import type { ProjectNameAndRootOptions } from '@nx/devkit/internal';
-// nx-ignore-next-line
-const { Linter, LinterType } = require('@nx/eslint'); // use require to import to avoid circular dependency
+import type { LinterType } from '../../utils/linter';
 import type { ProjectPackageManagerWorkspaceState } from '../../utils/package-manager-workspaces';
 
 export type Compiler = 'tsc' | 'swc';
@@ -15,7 +14,7 @@ export interface LibraryGeneratorSchema {
   skipPackageJson?: boolean;
   includeBabelRc?: boolean;
   unitTestRunner?: 'jest' | 'vitest' | 'none';
-  linter?: Linter | LinterType;
+  linter?: LinterType;
   testEnvironment?: 'jsdom' | 'node';
   importPath?: string;
   js?: boolean;
@@ -42,6 +41,8 @@ export interface LibraryGeneratorSchema {
 export interface NormalizedLibraryGeneratorOptions
   extends LibraryGeneratorSchema {
   name: string;
+  /** `normalizeOptions` always resolves this, so it is no longer optional. */
+  linter: LinterType;
   projectNames: ProjectNameAndRootOptions['names'];
   fileName: string;
   projectRoot: string;

package/dist/src/generators/library/schema.json

@@ -29,9 +29,9 @@
       "x-priority": "important"
     },
     "linter": {
-      "description": "The tool to use for running lint checks.",
+      "description": "The tool to use for running lint checks. Defaults to the linter the workspace already uses.",
       "type": "string",
-      "enum": ["none", "eslint"],
+      "enum": ["none", "eslint", "oxlint"],
       "x-priority": "important"
     },
     "unitTestRunner": {

package/dist/src/index.d.ts

@@ -16,5 +16,6 @@ export { initGenerator } from './generators/init/init';
 export { setupPrettierGenerator } from './generators/setup-prettier/generator';
 export { setupVerdaccio } from './generators/setup-verdaccio/generator';
 export { isValidVariable } from './utils/is-valid-variable';
+export { type LinterType } from './utils/linter';
 export { createLockFile, getLockFileName } from '@nx/devkit/internal';
 export { createPackageJson } from '@nx/devkit/internal';

package/dist/src/utils/add-linting-to-project.d.ts

@@ -0,0 +1,46 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { type LinterType } from './linter';
+export interface AddLintingToProjectOptions {
+    /** Required, but `undefined` still reaches here — see the normalization below. */
+    linter: LinterType | undefined;
+    project: string;
+    skipPackageJson?: boolean;
+    keepExistingVersions?: boolean;
+    addPlugin?: boolean;
+    /** ESLint-only. Ignored by other linters. */
+    tsConfigPaths?: string[];
+    unitTestRunner?: string;
+    /** ESLint-only. Ignored by other linters. */
+    rootProject?: boolean;
+    /** ESLint-only. Ignored by other linters. */
+    enableTypedLinting?: boolean;
+    /** ESLint-only. Oxlint is inference-only, so it writes no explicit target. */
+    addExplicitTargets?: boolean;
+    /**
+     * ESLint-only. The `@nx/dependency-checks` rule lints `package.json`, which
+     * Oxlint cannot read.
+     */
+    addPackageJsonDependencyChecks?: boolean;
+    /**
+     * Oxlint plugins to enable for this project, e.g. `['react', 'jsx-a11y']`.
+     * Ignored by other linters, which express framework presets differently.
+     */
+    oxlintPlugins?: string[];
+}
+/**
+ * Sets a project's linter up, dispatching to whichever linter the workspace
+ * asked for. Consumers call this instead of importing `lintProjectGenerator`
+ * from `@nx/eslint` directly, so adding a linter does not mean editing every
+ * generator. The two arms name different generators on purpose: `@nx/eslint`
+ * writes a lint target, while `@nx/oxlint` is inference-only and only
+ * configures the project.
+ *
+ * Scope is deliberately narrow: registering the linter and its project target.
+ * Linter-specific config shaping — ESLint framework presets, `extends`, ignore
+ * entries — stays at the call site guarded on `linter`, because none of it has
+ * a cross-linter equivalent.
+ *
+ * Both plugins are loaded through `ensurePackage`; a static import would be
+ * circular, since both depend on `@nx/js`.
+ */
+export declare function addLintingToProject(tree: Tree, options: AddLintingToProjectOptions): Promise<GeneratorCallback>;

package/dist/src/utils/add-linting-to-project.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLintingToProject = addLintingToProject;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const versions_1 = require("./versions");
+const linter_1 = require("./linter");
+/**
+ * Sets a project's linter up, dispatching to whichever linter the workspace
+ * asked for. Consumers call this instead of importing `lintProjectGenerator`
+ * from `@nx/eslint` directly, so adding a linter does not mean editing every
+ * generator. The two arms name different generators on purpose: `@nx/eslint`
+ * writes a lint target, while `@nx/oxlint` is inference-only and only
+ * configures the project.
+ *
+ * Scope is deliberately narrow: registering the linter and its project target.
+ * Linter-specific config shaping — ESLint framework presets, `extends`, ignore
+ * entries — stays at the call site guarded on `linter`, because none of it has
+ * a cross-linter equivalent.
+ *
+ * Both plugins are loaded through `ensurePackage`; a static import would be
+ * circular, since both depend on `@nx/js`.
+ */
+async function addLintingToProject(tree, options) {
+    // Callers should resolve this themselves, since their own guards need a
+    // concrete value. Resolving again here keeps a caller that forgets from
+    // silently getting ESLint in a workspace that uses something else.
+    const linter = options.linter ?? (0, linter_1.detectLinters)(tree)[0] ?? 'none';
+    if (linter === 'none') {
+        return () => { };
+    }
+    if (linter === 'oxlint') {
+        // `ensurePackage` installs by package name, so the subpath is required
+        // separately. `nx-ignore-next-line` keeps this out of the import graph, so
+        // the dependency stays a devDependency of this package rather than a runtime
+        // one. That devDependency is what makes the `js` <-> `@nx/oxlint` cycle,
+        // which is deliberate and recorded in `ignoredCircularDependencies` in the
+        // root eslint config.
+        (0, devkit_1.ensurePackage)('@nx/oxlint', versions_1.nxVersion);
+        // `@nx/oxlint` is the only ESM package under `packages/` and its
+        // `./generators` subpath has no `require` condition, so a bare `require()`
+        // throws ERR_REQUIRE_ESM below Node 20.19 / 22.12.
+        //
+        // Resolve to an absolute path before importing. `ensurePackage` exposes an
+        // on-demand install by adding a temp dir to NODE_PATH, which `require.resolve`
+        // honours and the ESM loader does not — so handing `import()` a bare specifier
+        // fails with ERR_MODULE_NOT_FOUND on exactly the Node band this indirection
+        // exists for. `load-resolved-plugin.ts` calls `handleImport` the same way.
+        // nx-ignore-next-line
+        const generatorsPath = require.resolve('@nx/oxlint/generators', {
+            paths: [devkit_1.workspaceRoot, __dirname],
+        });
+        const { configurationGenerator } = await (0, internal_1.handleImport)(generatorsPath);
+        return configurationGenerator(tree, {
+            project: options.project,
+            plugins: [
+                ...(options.oxlintPlugins ?? []),
+                ...oxlintTestPlugins(options.unitTestRunner),
+            ],
+            skipFormat: true,
+            skipPackageJson: options.skipPackageJson,
+            keepExistingVersions: options.keepExistingVersions,
+            // No `addPlugin`: `@nx/oxlint` is inference-only, so it always registers.
+        });
+    }
+    if (linter === 'eslint') {
+        const { lintProjectGenerator } = (0, devkit_1.ensurePackage)('@nx/eslint', versions_1.nxVersion);
+        return lintProjectGenerator(tree, {
+            linter,
+            project: options.project,
+            tsConfigPaths: options.tsConfigPaths,
+            unitTestRunner: options.unitTestRunner,
+            rootProject: options.rootProject,
+            enableTypedLinting: options.enableTypedLinting,
+            addExplicitTargets: options.addExplicitTargets,
+            addPackageJsonDependencyChecks: options.addPackageJsonDependencyChecks,
+            skipFormat: true,
+            skipPackageJson: options.skipPackageJson,
+            keepExistingVersions: options.keepExistingVersions,
+            addPlugin: options.addPlugin,
+        });
+    }
+    // Spelling ESLint out as its own branch rather than letting it be the
+    // fallthrough: a new `LinterType` member then fails to compile here instead of
+    // silently getting an ESLint setup.
+    const unhandled = linter;
+    throw new Error(`Unsupported linter: ${unhandled}`);
+}
+/**
+ * Which Oxlint plugins a test runner needs is the runner package's knowledge,
+ * so it is read from there rather than hardcoded here — this only maps the
+ * runner name to its package. Matched loosely because runners arrive with
+ * suffixes, e.g. Angular's `vitest-analog`. Both packages are already installed
+ * by the time the runner's own generator runs; `ensurePackage` keeps them out
+ * of the import graph, since both depend on `@nx/js`.
+ */
+function oxlintTestPlugins(unitTestRunner) {
+    const pkg = unitTestRunner?.includes('vitest')
+        ? '@nx/vitest'
+        : unitTestRunner?.includes('jest')
+            ? '@nx/jest'
+            : undefined;
+    if (!pkg) {
+        return [];
+    }
+    // `ensurePackage` installs by package name, so the `internal` subpath is
+    // required separately. Plain `require` holds only while both runners are CJS;
+    // `@nx/oxlint` is ESM, which is why the arm above needs `handleImport`.
+    (0, devkit_1.ensurePackage)(pkg, versions_1.nxVersion);
+    const { oxlintPlugins } = require(`${pkg}/internal`);
+    return oxlintPlugins ?? [];
+}

package/dist/src/utils/generator-prompts.d.ts

@@ -1,3 +1,4 @@
 import type { Tree } from '@nx/devkit';
-export declare function normalizeLinterOption(tree: Tree, linter: undefined | 'none' | 'eslint'): Promise<'none' | 'eslint'>;
+import { type LinterType } from './linter';
+export declare function normalizeLinterOption(tree: Tree, linter: undefined | LinterType): Promise<LinterType>;
 export declare function normalizeUnitTestRunnerOption<T extends 'none' | 'jest' | 'vitest'>(tree: Tree, unitTestRunner: undefined | T, testRunners?: Array<'jest' | 'vitest'>): Promise<T>;

package/dist/src/utils/generator-prompts.js

@@ -4,22 +4,27 @@ exports.normalizeLinterOption = normalizeLinterOption;
 exports.normalizeUnitTestRunnerOption = normalizeUnitTestRunnerOption;
 const internal_1 = require("@nx/devkit/internal");
 const ts_solution_setup_1 = require("./typescript/ts-solution-setup");
+const linter_1 = require("./linter");
 async function normalizeLinterOption(tree, linter) {
     if (linter) {
         return linter;
     }
-    const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
-    const choices = isTsSolutionSetup
-        ? [{ name: 'none' }, { name: 'eslint' }]
-        : [{ name: 'eslint' }, { name: 'none' }];
-    const defaultValue = isTsSolutionSetup ? 'none' : 'eslint';
+    // Following the workspace is not a question. When it already has a linter,
+    // use it — including in a hybrid workspace, where `detectLinters` puts the
+    // one being migrated *to* first. Pass `--linter` to choose something else.
+    const [detected] = (0, linter_1.detectLinters)(tree);
+    if (detected) {
+        return detected;
+    }
+    // Nothing to follow, so this is a real choice. `{ linter: 'none' }` is the
+    // non-interactive answer; `none` leads so the interactive default matches it.
     return await (0, internal_1.promptWhenInteractive)({
         type: 'autocomplete',
         name: 'linter',
         message: `Which linter would you like to use?`,
-        choices,
+        choices: [{ name: 'none' }, { name: 'eslint' }, { name: 'oxlint' }],
         initial: 0,
-    }, { linter: defaultValue }).then(({ linter }) => linter);
+    }, { linter: 'none' }).then(({ linter }) => linter);
 }
 async function normalizeUnitTestRunnerOption(tree, unitTestRunner, testRunners = ['jest', 'vitest']) {
     if (unitTestRunner) {

package/dist/src/utils/linter.d.ts

@@ -0,0 +1,30 @@
+import { type Tree } from '@nx/devkit';
+/**
+ * The linters Nx generators can set up for a project.
+ *
+ * Canonical home. `@nx/eslint` re-exports this for back-compat. Two standalone
+ * copies exist because neither package can depend on `@nx/js`: `@nx/workspace`
+ * (which `@nx/js` itself depends on) and `LINTERS` in `create-nx-workspace`.
+ * The assertion below pins the first; `create-nx-workspace` has no edge to
+ * assert across, so that one is still kept in sync by hand.
+ */
+export type LinterType = 'eslint' | 'oxlint' | 'none';
+/**
+ * Every linter the workspace has installed, most-preferred first — so `[0]` is
+ * the one a generator should follow when it was not told which to set up, and
+ * `.includes(x)` answers whether the workspace uses `x` at all. Those differ in
+ * a workspace part-way through a migration: it has both, and a project
+ * generated for Oxlint still lives under the root ESLint config.
+ *
+ * Oxlint sorts first when both are present. A workspace with both has adopted
+ * Oxlint alongside its existing ESLint setup, and new projects should follow
+ * the direction of travel rather than the setup being migrated away from.
+ *
+ * Empty means the workspace opted out of linting; callers that need a concrete
+ * answer should read that as `none` rather than inferring ESLint for it.
+ *
+ * Reads the tree, never the generator's own module resolution: `eslint` is a
+ * peer dependency of several first-party plugins, so it resolves from disk in
+ * workspaces that do not use it.
+ */
+export declare function detectLinters(tree: Tree): Exclude<LinterType, 'none'>[];

package/dist/src/utils/linter.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectLinters = detectLinters;
+const devkit_1 = require("@nx/devkit");
+function hasPlugin(tree, plugin) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    return !!nxJson?.plugins?.some((p) => typeof p === 'string' ? p === plugin : p.plugin === plugin);
+}
+function hasAnyDependency(tree, packages) {
+    return packages.some((pkg) => Boolean((0, devkit_1.getDependencyVersionFromPackageJson)(tree, pkg)));
+}
+/**
+ * Every linter the workspace has installed, most-preferred first — so `[0]` is
+ * the one a generator should follow when it was not told which to set up, and
+ * `.includes(x)` answers whether the workspace uses `x` at all. Those differ in
+ * a workspace part-way through a migration: it has both, and a project
+ * generated for Oxlint still lives under the root ESLint config.
+ *
+ * Oxlint sorts first when both are present. A workspace with both has adopted
+ * Oxlint alongside its existing ESLint setup, and new projects should follow
+ * the direction of travel rather than the setup being migrated away from.
+ *
+ * Empty means the workspace opted out of linting; callers that need a concrete
+ * answer should read that as `none` rather than inferring ESLint for it.
+ *
+ * Reads the tree, never the generator's own module resolution: `eslint` is a
+ * peer dependency of several first-party plugins, so it resolves from disk in
+ * workspaces that do not use it.
+ */
+function detectLinters(tree) {
+    const linters = [];
+    if (hasPlugin(tree, '@nx/oxlint') ||
+        hasAnyDependency(tree, ['@nx/oxlint', 'oxlint'])) {
+        linters.push('oxlint');
+    }
+    // `@nx/eslint` registers its inference plugin as `@nx/eslint/plugin`, unlike
+    // `@nx/oxlint`, which registers under its bare package name.
+    if (hasPlugin(tree, '@nx/eslint/plugin') ||
+        hasAnyDependency(tree, ['@nx/eslint', 'eslint'])) {
+        linters.push('eslint');
+    }
+    return linters;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "23.2.0-beta.6",
+  "version": "23.2.0-beta.7",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -147,11 +147,18 @@
     "source-map-support": "0.5.19",
     "tinyglobby": "^0.2.12",
     "tslib": "^2.3.0",
-    "@nx/devkit": "23.2.0-beta.6",
-    "@nx/workspace": "23.2.0-beta.6"
+    "@nx/devkit": "23.2.0-beta.7",
+    "@nx/workspace": "23.2.0-beta.7"
   },
   "devDependencies": {
-    "nx": "23.2.0-beta.6"
+    "@nx/esbuild": "23.2.0-beta.7",
+    "@nx/jest": "23.2.0-beta.7",
+    "@nx/eslint": "23.2.0-beta.7",
+    "@nx/oxlint": "23.2.0-beta.7",
+    "@nx/rollup": "23.2.0-beta.7",
+    "@nx/vite": "23.2.0-beta.7",
+    "@nx/vitest": "23.2.0-beta.7",
+    "nx": "23.2.0-beta.7"
   },
   "peerDependencies": {
     "@swc/cli": ">=0.6.0 <0.9.0",