@nx/js 23.2.0-beta.0 → 23.2.0-beta.10

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/assets/copy-assets-handler.d.ts

@@ -1,6 +1,6 @@
 import { AssetGlob } from './assets';
 import { normalizeAssets, getAssetOutputPath, NormalizedAssetEntry as AssetEntry } from './normalize-assets';
-import { ChangedFile } from 'nx/src/daemon/client/client';
+import { ChangedFile } from '@nx/devkit/internal';
 export type { AssetEntry };
 export { normalizeAssets, getAssetOutputPath };
 export type FileEventType = 'create' | 'update' | 'delete';

package/dist/src/utils/assets/copy-assets-handler.js

@@ -12,7 +12,7 @@ const normalize_assets_1 = require("./normalize-assets");
 Object.defineProperty(exports, "normalizeAssets", { enumerable: true, get: function () { return normalize_assets_1.normalizeAssets; } });
 Object.defineProperty(exports, "getAssetOutputPath", { enumerable: true, get: function () { return normalize_assets_1.getAssetOutputPath; } });
 const devkit_1 = require("@nx/devkit");
-const client_1 = require("nx/src/daemon/client/client");
+const internal_1 = require("@nx/devkit/internal");
 const picocolors_1 = require("picocolors");
 const defaultFileEventHandler = (events) => {
     const dirs = new Set(events.map((event) => path.dirname(event.dest)));
@@ -93,7 +93,7 @@ class CopyAssetsHandler {
         return ['**/node_modules/**', '**/.git/**'];
     }
     async watchAndProcessOnAssetChange() {
-        const unregisterFileWatcher = await client_1.daemonClient.registerFileWatcher({
+        const unregisterFileWatcher = await internal_1.daemonClient.registerFileWatcher({
             watchProjects: 'all',
             includeGlobalWorkspaceFiles: true,
         }, (err, data) => {

package/dist/src/utils/buildable-libs-utils.js

@@ -9,14 +9,11 @@ exports.updatePaths = updatePaths;
 exports.updateBuildableProjectPackageJsonDependencies = updateBuildableProjectPackageJsonDependencies;
 const devkit_1 = require("@nx/devkit");
 const fs_1 = require("fs");
-const operators_1 = require("nx/src/project-graph/operators");
-const fileutils_1 = require("nx/src/utils/fileutils");
-const output_1 = require("nx/src/utils/output");
 const path_1 = require("path");
 const ts_config_1 = require("./typescript/ts-config");
 const strip_glob_to_base_dir_1 = require("./strip-glob-to-base-dir");
 const crypto_1 = require("crypto");
-const project_graph_1 = require("nx/src/config/project-graph");
+const internal_1 = require("@nx/devkit/internal");
 function isBuildable(target, node) {
     return (node.data.targets &&
         node.data.targets[target] &&
@@ -49,11 +46,11 @@ function calculateProjectDependencies(projGraph, root, projectName, targetName,
         .map(({ name: dep, isTopLevel }) => {
         let project = null;
         const depNode = projGraph.nodes[dep] || projGraph.externalNodes[dep];
-        if ((0, project_graph_1.isProjectGraphProjectNode)(depNode) && depNode.type === 'lib') {
+        if ((0, internal_1.isProjectGraphProjectNode)(depNode) && depNode.type === 'lib') {
             if (isBuildable(targetName, depNode)) {
                 const libPackageJsonPath = (0, path_1.join)(root, depNode.data.root, 'package.json');
                 project = {
-                    name: (0, fileutils_1.fileExists)(libPackageJsonPath)
+                    name: (0, internal_1.fileExists)(libPackageJsonPath)
                         ? (0, devkit_1.readJsonFile)(libPackageJsonPath).name // i.e. @workspace/mylib
                         : dep,
                     outputs: (0, devkit_1.getOutputsForTargetAndConfiguration)({
@@ -68,7 +65,7 @@ function calculateProjectDependencies(projGraph, root, projectName, targetName,
                 nonBuildableDependencies.push(dep);
             }
         }
-        else if ((0, project_graph_1.isProjectGraphExternalNode)(depNode)) {
+        else if ((0, internal_1.isProjectGraphExternalNode)(depNode)) {
             project = {
                 name: depNode.data.packageName,
                 outputs: [],
@@ -130,7 +127,7 @@ function readTsConfigWithRemappedPaths(originalTsconfigPath, generatedTsconfigPa
     }
     generatedTsConfig.compilerOptions.paths = paths;
     if (process.env.NX_VERBOSE_LOGGING_PATH_MAPPINGS === 'true') {
-        output_1.output.log({
+        devkit_1.output.log({
             title: 'TypeScript path mappings have been rewritten.',
         });
         console.log(JSON.stringify(generatedTsConfig.compilerOptions.paths, null, 2));
@@ -158,7 +155,7 @@ function calculateDependenciesFromTaskGraph(taskGraph, projectGraph, root, proje
         }
         const libPackageJsonPath = (0, path_1.join)(root, depProjectNode.data.root, 'package.json');
         project = {
-            name: (0, fileutils_1.fileExists)(libPackageJsonPath)
+            name: (0, internal_1.fileExists)(libPackageJsonPath)
                 ? (0, devkit_1.readJsonFile)(libPackageJsonPath).name // i.e. @workspace/mylib
                 : depTask.target.project,
             outputs,
@@ -264,7 +261,7 @@ function updatePaths(dependencies, paths) {
     const pathsKeys = Object.keys(paths);
     // For each registered dependency
     dependencies
-        .filter((dep) => (0, project_graph_1.isProjectGraphProjectNode)(dep.node))
+        .filter((dep) => (0, internal_1.isProjectGraphProjectNode)(dep.node))
         .forEach((dep) => {
         // If there are outputs
         if (dep.outputs && dep.outputs.length > 0) {
@@ -335,7 +332,7 @@ function updateBuildableProjectPackageJsonDependencies(root, projectName, target
     packageJson.peerDependencies = packageJson.peerDependencies || {};
     let updatePackageJson = false;
     dependencies.forEach((entry) => {
-        const packageName = (0, operators_1.isNpmProject)(entry.node)
+        const packageName = (0, internal_1.isNpmProject)(entry.node)
             ? entry.node.data.packageName
             : entry.name;
         if (!hasDependency(packageJson, 'dependencies', packageName) &&
@@ -343,7 +340,7 @@ function updateBuildableProjectPackageJsonDependencies(root, projectName, target
             !hasDependency(packageJson, 'peerDependencies', packageName)) {
             try {
                 let depVersion;
-                if ((0, project_graph_1.isProjectGraphProjectNode)(entry.node) &&
+                if ((0, internal_1.isProjectGraphProjectNode)(entry.node) &&
                     entry.node.type === 'lib') {
                     const outputs = (0, devkit_1.getOutputsForTargetAndConfiguration)({
                         project: projectName,
@@ -354,7 +351,7 @@ function updateBuildableProjectPackageJsonDependencies(root, projectName, target
                     depVersion = (0, devkit_1.readJsonFile)(depPackageJsonPath).version;
                     packageJson[typeOfDependency][packageName] = depVersion;
                 }
-                else if ((0, operators_1.isNpmProject)(entry.node)) {
+                else if ((0, internal_1.isNpmProject)(entry.node)) {
                     // If an npm dep is part of the workspace devDependencies, do not include it the library
                     if (!!workspacePackageJson.devDependencies?.[entry.node.data.packageName]) {
                         return;

package/dist/src/utils/find-npm-dependencies.js

@@ -2,12 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findNpmDependencies = findNpmDependencies;
 const path_1 = require("path");
-const configuration_1 = require("nx/src/config/configuration");
 const devkit_1 = require("@nx/devkit");
-const fileutils_1 = require("nx/src/utils/fileutils");
-const project_graph_1 = require("nx/src/config/project-graph");
 const ts_config_1 = require("./typescript/ts-config");
-const task_hasher_1 = require("nx/src/hasher/task-hasher");
+const internal_1 = require("@nx/devkit/internal");
 /**
  * Finds all npm dependencies and their expected versions for a given project.
  */
@@ -44,14 +41,14 @@ function collectDependenciesFromFileMap(workspaceRoot, sourceProject, projectGra
     // If build target does not exist in project, use all files as input.
     // This is needed for transitive dependencies for apps -- where libs may not be buildable.
     const inputs = sourceProject.data.targets[buildTarget]
-        ? (0, task_hasher_1.getTargetInputs)((0, configuration_1.readNxJson)(), sourceProject, buildTarget).selfInputs
+        ? (0, internal_1.getTargetInputs)((0, internal_1.readNxJsonFromDisk)(), sourceProject, buildTarget).selfInputs
         : ['{projectRoot}/**/*'];
     if (ignoredFiles) {
         for (const pattern of ignoredFiles) {
             inputs.push(`!${pattern}`);
         }
     }
-    const files = (0, task_hasher_1.filterUsingGlobPatterns)(sourceProject.data.root, projectFileMap[sourceProject.name] || [], inputs);
+    const files = (0, internal_1.filterUsingGlobPatterns)(sourceProject.data.root, projectFileMap[sourceProject.name] || [], inputs);
     for (const fileData of files) {
         if (!fileData.deps ||
             fileData.file ===
@@ -59,7 +56,7 @@ function collectDependenciesFromFileMap(workspaceRoot, sourceProject, projectGra
             continue;
         }
         for (const dep of fileData.deps) {
-            const target = (0, project_graph_1.fileDataDepTarget)(dep);
+            const target = (0, internal_1.fileDataDepTarget)(dep);
             // If the node is external, then read package info from `data`.
             const externalDep = projectGraph.externalNodes[target];
             if (externalDep?.type === 'npm') {
@@ -110,7 +107,7 @@ function collectDependenciesFromFileMap(workspaceRoot, sourceProject, projectGra
 }
 function readPackageJson(project, workspaceRoot) {
     const packageJsonPath = (0, path_1.join)(workspaceRoot, project.data.root, 'package.json');
-    if ((0, fileutils_1.fileExists)(packageJsonPath))
+    if ((0, internal_1.fileExists)(packageJsonPath))
         return (0, devkit_1.readJsonFile)(packageJsonPath);
     return null;
 }
@@ -139,7 +136,7 @@ function collectHelperDependencies(workspaceRoot, sourceProject, projectGraph, b
         const swcConfigPath = target.options.swcrc
             ? (0, path_1.join)(workspaceRoot, target.options.swcrc)
             : (0, path_1.join)(workspaceRoot, sourceProject.data.root, '.swcrc');
-        const swcConfig = (0, fileutils_1.fileExists)(swcConfigPath)
+        const swcConfig = (0, internal_1.fileExists)(swcConfigPath)
             ? (0, devkit_1.readJsonFile)(swcConfigPath)
             : {};
         if (swcConfig?.jsc?.externalHelpers &&
@@ -169,7 +166,7 @@ function resolveTsConfigForRunCommandsTarget(workspaceRoot, sourceProject, targe
         const resolved = (0, path_1.isAbsolute)(commandTsConfig)
             ? commandTsConfig
             : (0, path_1.join)(cwdAbsolute, commandTsConfig);
-        if ((0, fileutils_1.fileExists)(resolved))
+        if ((0, internal_1.fileExists)(resolved))
             return resolved;
     }
     // Preserves prior behavior when the tsconfig can't be determined from the command.

package/dist/src/utils/formatter-setup.d.ts

@@ -0,0 +1,26 @@
+import type { GeneratorCallback, Tree } from '@nx/devkit';
+type FormatterSetup = {
+    setUp: (tree: Tree, options: {
+        skipPackageJson?: boolean;
+    }) => GeneratorCallback;
+    version: string;
+};
+/**
+ * The setup for a formatter name that came from a schema, or `undefined` for
+ * `'none'` and anything unrecognised.
+ *
+ * `hasOwnProperty` rather than `in`, which would answer `true` for inherited
+ * members like `'constructor'` and hand back an `Object.prototype` function.
+ */
+export declare function getFormatterSetup(formatter: string | undefined): FormatterSetup | undefined;
+/**
+ * Writes the chosen formatter's config and queues its install.
+ *
+ * For callers that only need the formatter configured - a preset that creates
+ * an empty workspace, say - rather than the whole of `@nx/js:init`. Does
+ * nothing for `'none'` or an unrecognised value.
+ */
+export declare function setUpFormatter(tree: Tree, formatter: string | undefined, options?: {
+    skipPackageJson?: boolean;
+}): GeneratorCallback;
+export {};

package/dist/src/utils/formatter-setup.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFormatterSetup = getFormatterSetup;
+exports.setUpFormatter = setUpFormatter;
+const oxfmt_1 = require("./oxfmt");
+const prettier_1 = require("./prettier");
+const versions_1 = require("./versions");
+/**
+ * Not `Partial`, so a new `FormatterType` member fails to compile here until it
+ * is set up - but only after `packages/nx` is rebuilt, since the type comes
+ * from its emitted declarations. The guard must stay structural: under
+ * `strict: false` an untyped lookup yields `any` instead of an error.
+ *
+ * The key doubles as the npm package name; callers install by it.
+ */
+const formatterSetups = {
+    prettier: { setUp: prettier_1.generatePrettierSetup, version: versions_1.prettierVersion },
+    oxfmt: { setUp: oxfmt_1.generateOxfmtSetup, version: versions_1.oxfmtVersion },
+};
+/**
+ * The setup for a formatter name that came from a schema, or `undefined` for
+ * `'none'` and anything unrecognised.
+ *
+ * `hasOwnProperty` rather than `in`, which would answer `true` for inherited
+ * members like `'constructor'` and hand back an `Object.prototype` function.
+ */
+function getFormatterSetup(formatter) {
+    return formatter !== undefined &&
+        Object.prototype.hasOwnProperty.call(formatterSetups, formatter)
+        ? formatterSetups[formatter]
+        : undefined;
+}
+/**
+ * Writes the chosen formatter's config and queues its install.
+ *
+ * For callers that only need the formatter configured - a preset that creates
+ * an empty workspace, say - rather than the whole of `@nx/js:init`. Does
+ * nothing for `'none'` or an unrecognised value.
+ */
+function setUpFormatter(tree, formatter, options = {}) {
+    const setup = getFormatterSetup(formatter);
+    return setup ? setup.setUp(tree, options) : () => { };
+}

package/dist/src/utils/generate-globs.js

@@ -3,16 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createGlobPatternsForDependencies = createGlobPatternsForDependencies;
 const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
-const workspace_root_1 = require("nx/src/utils/workspace-root");
 const path_1 = require("path");
-const project_graph_1 = require("nx/src/project-graph/project-graph");
-const project_graph_utils_1 = require("nx/src/utils/project-graph-utils");
 const fs_1 = require("fs");
 const ignore_1 = tslib_1.__importDefault(require("ignore"));
-const find_project_for_path_1 = require("nx/src/project-graph/utils/find-project-for-path");
+const internal_1 = require("@nx/devkit/internal");
 function configureIgnore() {
     let ig;
-    const pathToGitIgnore = (0, path_1.join)(workspace_root_1.workspaceRoot, '.gitignore');
+    const pathToGitIgnore = (0, path_1.join)(devkit_1.workspaceRoot, '.gitignore');
     if ((0, fs_1.existsSync)(pathToGitIgnore)) {
         ig = (0, ignore_1.default)();
         ig.add((0, fs_1.readFileSync)(pathToGitIgnore, { encoding: 'utf-8' }));
@@ -26,13 +23,13 @@ function configureIgnore() {
  */
 function createGlobPatternsForDependencies(dirPath, fileGlobPattern) {
     let ig = configureIgnore();
-    const filenameRelativeToWorkspaceRoot = (0, devkit_1.normalizePath)((0, path_1.relative)(workspace_root_1.workspaceRoot, dirPath));
-    const projectGraph = (0, project_graph_1.readCachedProjectGraph)();
-    const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappings)(projectGraph.nodes);
+    const filenameRelativeToWorkspaceRoot = (0, devkit_1.normalizePath)((0, path_1.relative)(devkit_1.workspaceRoot, dirPath));
+    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
+    const projectRootMappings = (0, internal_1.createProjectRootMappings)(projectGraph.nodes);
     // find the project
     let projectName;
     try {
-        projectName = (0, find_project_for_path_1.findProjectForPath)(filenameRelativeToWorkspaceRoot, projectRootMappings);
+        projectName = (0, internal_1.findProjectForPath)(filenameRelativeToWorkspaceRoot, projectRootMappings);
         if (!projectName) {
             throw new Error(`createGlobPatternsForDependencies: Could not find any project containing the file "${filenameRelativeToWorkspaceRoot}" among it's project files`);
         }
@@ -42,17 +39,17 @@ function createGlobPatternsForDependencies(dirPath, fileGlobPattern) {
     }
     // generate the glob
     try {
-        const [projectDirs, warnings] = (0, project_graph_utils_1.getSourceDirOfDependentProjects)(projectName, projectGraph);
+        const [projectDirs, warnings] = (0, internal_1.getSourceDirOfDependentProjects)(projectName, projectGraph);
         const dirsToUse = [];
         const recursiveScanDirs = (dirPath) => {
-            const children = (0, fs_1.readdirSync)((0, path_1.resolve)(workspace_root_1.workspaceRoot, dirPath));
+            const children = (0, fs_1.readdirSync)((0, path_1.resolve)(devkit_1.workspaceRoot, dirPath));
             for (const child of children) {
                 const childPath = (0, path_1.join)(dirPath, child);
                 if (ig?.ignores(childPath) ||
-                    !(0, fs_1.lstatSync)((0, path_1.resolve)(workspace_root_1.workspaceRoot, childPath)).isDirectory()) {
+                    !(0, fs_1.lstatSync)((0, path_1.resolve)(devkit_1.workspaceRoot, childPath)).isDirectory()) {
                     continue;
                 }
-                if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, childPath, 'ng-package.json'))) {
+                if ((0, fs_1.existsSync)((0, path_1.join)(devkit_1.workspaceRoot, childPath, 'ng-package.json'))) {
                     dirsToUse.push(childPath);
                 }
                 else {
@@ -72,7 +69,7 @@ ${warnings.join('\n- ')}\n
 due to missing "sourceRoot" in the dependencies' project configuration
       `);
         }
-        return dirsToUse.map((sourceDir) => (0, path_1.resolve)(workspace_root_1.workspaceRoot, (0, devkit_1.joinPathFragments)(sourceDir, fileGlobPattern)));
+        return dirsToUse.map((sourceDir) => (0, path_1.resolve)(devkit_1.workspaceRoot, (0, devkit_1.joinPathFragments)(sourceDir, fileGlobPattern)));
     }
     catch (e) {
         throw new Error(`createGlobPatternsForDependencies: Error when generating globs.\n${e?.message}`);

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,37 +4,38 @@ 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';
-    return await (0, internal_1.promptWhenInteractive)({
-        type: 'autocomplete',
-        name: 'linter',
-        message: `Which linter would you like to use?`,
-        choices,
-        initial: 0,
-    }, { linter: defaultValue }).then(({ linter }) => linter);
+    // 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. `none` is the non-interactive
+    // answer, and leads the list so the interactive default matches it.
+    return (0, internal_1.isInteractive)()
+        ? (0, internal_1.selectPrompt)({
+            message: `Which linter would you like to use?`,
+            choices: [{ value: 'none' }, { value: 'eslint' }, { value: 'oxlint' }],
+        })
+        : 'none';
 }
 async function normalizeUnitTestRunnerOption(tree, unitTestRunner, testRunners = ['jest', 'vitest']) {
     if (unitTestRunner) {
         return unitTestRunner;
     }
     const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
-    const choices = isTsSolutionSetup
-        ? [{ name: 'none' }, ...testRunners.map((runner) => ({ name: runner }))]
-        : [...testRunners.map((runner) => ({ name: runner })), { name: 'none' }];
+    const choices = (isTsSolutionSetup ? ['none', ...testRunners] : [...testRunners, 'none']).map((value) => ({ value: value }));
     const defaultValue = (isTsSolutionSetup ? 'none' : testRunners[0]);
-    return await (0, internal_1.promptWhenInteractive)({
-        type: 'autocomplete',
-        name: 'unitTestRunner',
-        message: `Which unit test runner would you like to use?`,
-        choices,
-        initial: 0,
-    }, { unitTestRunner: defaultValue }).then(({ unitTestRunner }) => unitTestRunner);
+    return (0, internal_1.isInteractive)()
+        ? (0, internal_1.selectPrompt)({
+            message: `Which unit test runner would you like to use?`,
+            choices,
+        })
+        : defaultValue;
 }

package/dist/src/utils/get-main-file-dir.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRelativeDirectoryToProjectRoot = getRelativeDirectoryToProjectRoot;
 const path_1 = require("path");
-const path_2 = require("nx/src/utils/path");
+const devkit_1 = require("@nx/devkit");
 function getRelativeDirectoryToProjectRoot(file, projectRoot) {
     const dir = (0, path_1.dirname)(file);
-    const relativeDir = (0, path_2.normalizePath)((0, path_1.relative)(projectRoot, dir));
+    const relativeDir = (0, devkit_1.normalizePath)((0, path_1.relative)(projectRoot, dir));
     return relativeDir === '' ? `./` : `./${relativeDir}/`;
 }

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;
+}