@nx/js 23.2.0-beta.1 → 23.2.0-beta.11

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

package/dist/src/utils/npm-config.d.ts

@@ -1,4 +1,4 @@
-import { PackageJson } from 'nx/src/utils/package-json';
+import { PackageJson } from '@nx/devkit/internal';
 export declare function parseRegistryOptions(cwd: string, pkg: {
     packageRoot: string;
     packageJson: PackageJson;

package/dist/src/utils/nx-formatter-internals.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `@nx/js` inherits `@nx/devkit`'s `nx` peer, which spans a major either
+ * side, so an older nx without these helpers can legally be installed. A
+ * missing CommonJS named export arrives as `undefined`, so the first use
+ * would otherwise be a bare `undefined.every` naming neither package nor
+ * cause.
+ */
+export declare function assertNxSupportsFormatters(): void;

package/dist/src/utils/nx-formatter-internals.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNxSupportsFormatters = assertNxSupportsFormatters;
+const internal_1 = require("@nx/devkit/internal");
+/**
+ * `@nx/js` inherits `@nx/devkit`'s `nx` peer, which spans a major either
+ * side, so an older nx without these helpers can legally be installed. A
+ * missing CommonJS named export arrives as `undefined`, so the first use
+ * would otherwise be a bare `undefined.every` naming neither package nor
+ * cause.
+ */
+function assertNxSupportsFormatters() {
+    if (internal_1.detectFormatterInTree && internal_1.oxfmtConfigFiles && internal_1.prettierConfigFiles) {
+        return;
+    }
+    throw new Error('The installed version of nx does not export the formatter helpers that @nx/js needs to detect and set up a formatter. ' +
+        'This happens when nx and @nx/js are on different major versions. Run `nx migrate latest` to bring them into line.');
+}

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

@@ -0,0 +1,4 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+export declare function generateOxfmtSetup(tree: Tree, options: {
+    skipPackageJson?: boolean;
+}): GeneratorCallback;

package/dist/src/utils/oxfmt.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOxfmtSetup = generateOxfmtSetup;
+const devkit_1 = require("@nx/devkit");
+// Imported rather than copied: detection ("is this workspace using oxfmt?")
+// and setup ("should a config be written?") have to agree on the same list, or
+// a workspace that already has a config gets a second, redundant one.
+const internal_1 = require("@nx/devkit/internal");
+const nx_formatter_internals_1 = require("./nx-formatter-internals");
+const versions_1 = require("./versions");
+function generateOxfmtSetup(tree, options) {
+    (0, nx_formatter_internals_1.assertNxSupportsFormatters)();
+    if (internal_1.oxfmtConfigFiles.every((name) => !tree.exists(name))) {
+        // oxfmt defaults to double quotes and we prefer single, so that is the one
+        // option worth setting. Line width is left at oxfmt's default.
+        (0, devkit_1.writeJson)(tree, '.oxfmtrc.json', { singleQuote: true });
+    }
+    // The oxc extension is what drives oxfmt in the editor, so recommend it for
+    // the same reason the prettier setup recommends its own. Only when the file
+    // is already there - creating it would push an editor choice on a workspace
+    // that has not made one.
+    if (tree.exists('.vscode/extensions.json')) {
+        (0, devkit_1.updateJson)(tree, '.vscode/extensions.json', (json) => {
+            json.recommendations ??= [];
+            const extension = 'oxc.oxc-vscode';
+            if (!json.recommendations.includes(extension)) {
+                json.recommendations.push(extension);
+            }
+            return json;
+        });
+    }
+    return options.skipPackageJson
+        ? () => { }
+        : (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { oxfmt: versions_1.oxfmtVersion });
+}

package/dist/src/utils/package-json/update-package-json.d.ts

@@ -1,6 +1,6 @@
+import { type PackageJson } from '@nx/devkit/internal';
 import { ExecutorContext, ProjectFileMap, ProjectGraphProjectNode } from '@nx/devkit';
 import { DependentBuildableProjectNode } from '../buildable-libs-utils';
-import type { PackageJson } from 'nx/src/utils/package-json';
 export type SupportedFormat = 'cjs' | 'esm';
 export interface UpdatePackageJsonOption {
     rootDir?: string;

package/dist/src/utils/package-json/update-package-json.js

@@ -4,24 +4,19 @@ exports.updatePackageJson = updatePackageJson;
 exports.getExports = getExports;
 exports.getUpdatedPackageJsonContent = getUpdatedPackageJsonContent;
 exports.getOutputDir = getOutputDir;
-// eslint-disable-next-line @typescript-eslint/no-restricted-imports
-const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
-// eslint-disable-next-line @typescript-eslint/no-restricted-imports
-const create_package_json_1 = require("nx/src/plugins/js/package-json/create-package-json");
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const node_fs_1 = require("node:fs");
 const path_1 = require("path");
-const fileutils_1 = require("nx/src/utils/fileutils");
-const nx_deps_cache_1 = require("nx/src/project-graph/nx-deps-cache");
 const get_main_file_dir_1 = require("../get-main-file-dir");
 const strip_glob_to_base_dir_1 = require("../strip-glob-to-base-dir");
 function updatePackageJson(options, context, target, dependencies, fileMap = null) {
     let packageJson;
     if (fileMap == null) {
-        fileMap = (0, nx_deps_cache_1.readFileMapCache)()?.fileMap?.projectFileMap || {};
+        fileMap = (0, internal_1.readFileMapCache)()?.fileMap?.projectFileMap || {};
     }
     if (options.updateBuildableProjectDepsInPackageJson) {
-        packageJson = (0, create_package_json_1.createPackageJson)(context.projectName, context.projectGraph, {
+        packageJson = (0, internal_1.createPackageJson)(context.projectName, context.projectGraph, {
             target: context.targetName,
             root: context.root,
             // By default we remove devDependencies since this is a production build.
@@ -34,7 +29,7 @@ function updatePackageJson(options, context, target, dependencies, fileMap = nul
     }
     else {
         const pathToPackageJson = (0, path_1.join)(context.root, options.projectRoot, 'package.json');
-        packageJson = (0, fileutils_1.fileExists)(pathToPackageJson)
+        packageJson = (0, internal_1.fileExists)(pathToPackageJson)
             ? (0, devkit_1.readJsonFile)(pathToPackageJson)
             : { name: context.projectName, version: '0.0.1' };
     }
@@ -50,22 +45,16 @@ function updatePackageJson(options, context, target, dependencies, fileMap = nul
         }
         options.format = ['cjs'];
     }
-    // update package specific settings
     packageJson = getUpdatedPackageJsonContent(packageJson, options);
-    // save files
-    (0, devkit_1.writeJsonFile)(`${options.outputPath}/package.json`, packageJson);
+    const packageManager = (0, devkit_1.detectPackageManager)(context.root);
     if (options.generateLockfile) {
-        const packageManager = (0, devkit_1.detectPackageManager)(context.root);
-        if (packageManager === 'bun') {
-            devkit_1.logger.warn(`Bun lockfile generation is unsupported. Remove "generateLockfile" option or set it to false.`);
-        }
-        else {
-            const lockFile = (0, lock_file_1.createLockFile)(packageJson, context.projectGraph, packageManager);
-            (0, node_fs_1.writeFileSync)(`${options.outputPath}/${(0, lock_file_1.getLockFileName)(packageManager)}`, lockFile, {
-                encoding: 'utf-8',
-            });
-        }
+        (0, internal_1.generatePrunedDeployOutput)(packageJson, context.projectGraph, options.projectRoot, {
+            outputDirectory: options.outputPath,
+            packageManager,
+            workspaceRoot: context.root,
+        });
     }
+    (0, devkit_1.writeJsonFile)(`${options.outputPath}/package.json`, packageJson);
 }
 function isNpmNode(node, graph) {
     return !!(graph.externalNodes[node.name]?.type === 'npm');

package/dist/src/utils/package-manager-workspaces.js

@@ -8,8 +8,8 @@ exports.getProjectPackageManagerWorkspaceStateWarningTask = getProjectPackageMan
 const devkit_1 = require("@nx/devkit");
 const picomatch = require("picomatch");
 const posix_1 = require("node:path/posix");
-const package_json_1 = require("nx/src/plugins/package-json");
 const semver_1 = require("semver");
+const internal_1 = require("@nx/devkit/internal");
 function getProjectPackageManagerWorkspaceState(tree, projectRoot) {
     if (!isUsingPackageManagerWorkspaces(tree)) {
         return 'no-workspaces';
@@ -19,7 +19,7 @@ function getProjectPackageManagerWorkspaceState(tree, projectRoot) {
     return isIncluded ? 'included' : 'excluded';
 }
 function getPackageManagerWorkspacesPatterns(tree) {
-    return (0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (path) => (0, devkit_1.readJson)(tree, path, { expectComments: true }), (path) => {
+    return (0, internal_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (path) => (0, devkit_1.readJson)(tree, path, { expectComments: true }), (path) => {
         const content = tree.read(path, 'utf-8');
         const { load } = require('@zkochan/js-yaml');
         return load(content, { filename: path });