@nx/devkit 0.0.0-pr-30715-a5f5e3b → 0.0.0-pr-31222-862e973

package/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017-2025 Narwhal Technologies Inc.
+Copyright (c) 2017-2024 Narwhal Technologies Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/README.md

@@ -9,7 +9,7 @@
 
 [![CircleCI](https://circleci.com/gh/nrwl/nx.svg?style=svg)](https://circleci.com/gh/nrwl/nx)
 [![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
-[![NPM Version](https://badge.fury.io/js/nx.svg)](https://www.npmjs.com/package/nx)
+[![NPM Version](https://badge.fury.io/js/%40nrwl%2Fworkspace.svg)](https://www.npmjs.com/@nx/workspace)
 [![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
 [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
 [![Join the chat at https://gitter.im/nrwl-nx/community](https://badges.gitter.im/nrwl-nx/community.svg)](https://gitter.im/nrwl-nx/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

package/migrations.json

@@ -1,5 +1,18 @@
 {
-  "generators": {},
+  "generators": {
+    "update-16-0-0-add-nx-packages": {
+      "cli": "nx",
+      "version": "16.0.0-beta.1",
+      "description": "Replace @nrwl/devkit with @nx/devkit",
+      "implementation": "./src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages"
+    },
+    "update-16-9-0-migrate-mf-usage-to-webpack": {
+      "cli": "nx",
+      "version": "16.9.0-beta.1",
+      "description": "Replace imports of Module Federation utils frm @nx/devkit to @nx/webpack",
+      "implementation": "./src/migrations/update-16-9-0/migrate-mf-util-usage"
+    }
+  },
   "packageJsonUpdates": {},
   "version": "0.1"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/devkit",
-  "version": "0.0.0-pr-30715-a5f5e3b",
+  "version": "0.0.0-pr-31222-862e973",
   "private": false,
   "description": "The Nx Devkit is used to customize Nx for different technologies and use cases. It contains many utility functions for reading and writing files, updating configuration, working with Abstract Syntax Trees(ASTs), and more. Learn more about [extending Nx by leveraging the Nx Devkit](https://nx.dev/extending-nx/intro/getting-started) on our docs.",
   "repository": {
@@ -29,16 +29,17 @@
   "homepage": "https://nx.dev",
   "dependencies": {
     "ejs": "^3.1.7",
+    "enquirer": "~2.3.6",
     "ignore": "^5.0.4",
     "tmp": "~0.2.1",
     "tslib": "^2.3.0",
     "semver": "^7.5.3",
     "yargs-parser": "21.1.1",
     "minimatch": "9.0.3",
-    "enquirer": "~2.3.6"
+    "@nrwl/devkit": "0.0.0-pr-31222-862e973"
   },
   "peerDependencies": {
-    "nx": "0.0.0-pr-30715-a5f5e3b"
+    "nx": ">= 19 <= 21"
   },
   "publishConfig": {
     "access": "public"
@@ -46,6 +47,6 @@
   "nx-migrations": {
     "migrations": "./migrations.json"
   },
-  "types": "./index.d.ts",
-  "type": "commonjs"
+  "type": "commonjs",
+  "types": "./index.d.ts"
 }

package/src/executors/parse-target-string.d.ts

@@ -1,4 +1,8 @@
 import { ExecutorContext, ProjectGraph, Target } from 'nx/src/devkit-exports';
+/**
+ * @deprecated(v17) A project graph should be passed to parseTargetString for best accuracy.
+ */
+export declare function parseTargetString(targetString: string): Target;
 /**
  * Parses a target string into {project, target, configuration}
  *

package/src/executors/read-target-options.js

@@ -9,7 +9,7 @@ const devkit_internals_1 = require("nx/src/devkit-internals");
  * Works as if you invoked the target yourself without passing any command lint overrides.
  */
 function readTargetOptions({ project, target, configuration }, context) {
-    const projectConfiguration = context.projectsConfigurations.projects[project];
+    const projectConfiguration = (context.workspace || context.projectsConfigurations).projects[project];
     if (!projectConfiguration) {
         throw new Error(`Unable to find project ${project}`);
     }
@@ -17,8 +17,8 @@ function readTargetOptions({ project, target, configuration }, context) {
     if (!targetConfiguration) {
         throw new Error(`Unable to find target ${target} for project ${project}`);
     }
-    const [nodeModule, executorName] = (0, devkit_internals_1.parseExecutor)(targetConfiguration.executor);
-    const { schema } = (0, devkit_internals_1.getExecutorInformation)(nodeModule, executorName, context.root, context.projectsConfigurations?.projects);
+    const [nodeModule, executorName] = targetConfiguration.executor.split(':');
+    const { schema } = (0, devkit_internals_1.getExecutorInformation)(nodeModule, executorName, context.root, context.projectsConfigurations?.projects ?? context.workspace.projects);
     const defaultProject = (0, devkit_internals_1.calculateDefaultProjectName)(context.cwd, context.root, { version: 2, projects: context.projectsConfigurations.projects }, context.nxJsonConfiguration);
     return (0, devkit_internals_1.combineOptionsForExecutor)({}, configuration ?? targetConfiguration.defaultConfiguration ?? '', targetConfiguration, schema, defaultProject, (0, path_1.relative)(context.root, context.cwd));
 }

package/src/generators/artifact-name-and-directory-utils.d.ts

@@ -1,21 +1,21 @@
-import { type Tree } from 'nx/src/devkit-exports';
+import { Tree } from 'nx/src/devkit-exports';
+export type NameAndDirectoryFormat = 'as-provided' | 'derived';
 export type ArtifactGenerationOptions = {
-    path: string;
-    name?: string;
-    fileExtension?: string;
+    artifactType: string;
+    callingGenerator: string | null;
+    name: string;
+    directory?: string;
+    disallowPathInNameForDerived?: boolean;
+    fileExtension?: 'js' | 'jsx' | 'ts' | 'tsx' | 'vue';
+    fileName?: string;
+    flat?: boolean;
+    nameAndDirectoryFormat?: NameAndDirectoryFormat;
+    pascalCaseDirectory?: boolean;
+    pascalCaseFile?: boolean;
+    project?: string;
     suffix?: string;
-    suffixSeparator?: string;
-    allowedFileExtensions?: string[];
-    /**
-     * @deprecated Provide the full file path including the file extension in the `path` option. This option will be removed in Nx v21.
-     */
-    js?: boolean;
-    /**
-     * @deprecated Provide the full file path including the file extension in the `path` option. This option will be removed in Nx v21.
-     */
-    jsOptionName?: string;
+    derivedDirectory?: string;
 };
-export type FileExtensionType = 'js' | 'ts' | 'other';
 export type NameAndDirectoryOptions = {
     /**
      * Normalized artifact name.
@@ -29,14 +29,6 @@ export type NameAndDirectoryOptions = {
      * Normalized file name of the artifact without the extension.
      */
     fileName: string;
-    /**
-     * Normalized file extension.
-     */
-    fileExtension: string;
-    /**
-     * Normalized file extension type.
-     */
-    fileExtensionType: FileExtensionType;
     /**
      * Normalized full file path of the artifact.
      */
@@ -46,7 +38,9 @@ export type NameAndDirectoryOptions = {
      */
     project: string;
 };
-export declare function determineArtifactNameAndDirectoryOptions(tree: Tree, options: ArtifactGenerationOptions): Promise<NameAndDirectoryOptions>;
+export declare function determineArtifactNameAndDirectoryOptions(tree: Tree, options: ArtifactGenerationOptions): Promise<NameAndDirectoryOptions & {
+    nameAndDirectoryFormat: NameAndDirectoryFormat;
+}>;
 export declare function getRelativeCwd(): string;
 /**
  * Function for setting cwd during testing

package/src/generators/artifact-name-and-directory-utils.js

@@ -3,63 +3,210 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.determineArtifactNameAndDirectoryOptions = determineArtifactNameAndDirectoryOptions;
 exports.getRelativeCwd = getRelativeCwd;
 exports.setCwd = setCwd;
+const enquirer_1 = require("enquirer");
+const path_1 = require("path");
+const names_1 = require("../utils/names");
 const devkit_exports_1 = require("nx/src/devkit-exports");
 const devkit_internals_1 = require("nx/src/devkit-internals");
-const path_1 = require("path");
-const DEFAULT_ALLOWED_JS_FILE_EXTENSIONS = ['js', 'cjs', 'mjs', 'jsx'];
-const DEFAULT_ALLOWED_TS_FILE_EXTENSIONS = ['ts', 'cts', 'mts', 'tsx'];
-const DEFAULT_ALLOWED_FILE_EXTENSIONS = [
-    ...DEFAULT_ALLOWED_JS_FILE_EXTENSIONS,
-    ...DEFAULT_ALLOWED_TS_FILE_EXTENSIONS,
-    'vue',
-];
 async function determineArtifactNameAndDirectoryOptions(tree, options) {
-    const normalizedOptions = getNameAndDirectoryOptions(tree, options);
-    validateResolvedProject(normalizedOptions.project, normalizedOptions.directory);
-    return normalizedOptions;
+    if (!options.nameAndDirectoryFormat &&
+        (process.env.NX_INTERACTIVE !== 'true' || !isTTY())) {
+        options.nameAndDirectoryFormat = 'derived';
+    }
+    const formats = getNameAndDirectoryOptionFormats(tree, options);
+    const format = options.nameAndDirectoryFormat ?? (await determineFormat(formats, options));
+    validateResolvedProject(tree, formats[format]?.project, options, formats[format]?.directory);
+    if (format === 'derived' && options.callingGenerator) {
+        logDeprecationMessage(options, formats);
+    }
+    return {
+        ...formats[format],
+        nameAndDirectoryFormat: format,
+    };
 }
-function getNameAndDirectoryOptions(tree, options) {
-    const path = options.path
-        ? (0, devkit_exports_1.normalizePath)(options.path.replace(/^\.?\//, ''))
+async function determineFormat(formats, options) {
+    if (!formats.derived) {
+        return 'as-provided';
+    }
+    const asProvidedDescription = `As provided: ${formats['as-provided'].filePath}`;
+    const asProvidedSelectedValue = formats['as-provided'].filePath;
+    const derivedDescription = `Derived:     ${formats['derived'].filePath}`;
+    const derivedSelectedValue = formats['derived'].filePath;
+    if (asProvidedSelectedValue === derivedSelectedValue) {
+        return 'as-provided';
+    }
+    const result = await (0, enquirer_1.prompt)({
+        type: 'select',
+        name: 'format',
+        message: `Where should the ${options.artifactType} be generated?`,
+        choices: [
+            {
+                message: asProvidedDescription,
+                name: asProvidedSelectedValue,
+            },
+            {
+                message: derivedDescription,
+                name: derivedSelectedValue,
+            },
+        ],
+        initial: 0,
+    }).then(({ format }) => format === asProvidedSelectedValue ? 'as-provided' : 'derived');
+    return result;
+}
+function logDeprecationMessage(options, formats) {
+    devkit_exports_1.logger.warn(`
+In Nx 20, generating a ${options.artifactType} will no longer support providing a project and deriving the directory.
+Please provide the exact directory in the future.
+Example: nx g ${options.callingGenerator} ${formats['derived'].artifactName} --directory ${formats['derived'].directory}
+NOTE: The example above assumes the command is being run from the workspace root. If the command is being run from a subdirectory, the directory option should be adjusted accordingly.
+`);
+}
+function getNameAndDirectoryOptionFormats(tree, options) {
+    const directory = options.directory
+        ? (0, devkit_exports_1.normalizePath)(options.directory.replace(/^\.?\//, ''))
         : undefined;
-    let { name: extractedName, directory } = extractNameAndDirectoryFromPath(path);
-    const relativeCwd = getRelativeCwd();
-    // append the directory to the current working directory if it doesn't start with it
-    if (directory !== relativeCwd && !directory.startsWith(`${relativeCwd}/`)) {
-        directory = (0, devkit_exports_1.joinPathFragments)(relativeCwd, directory);
-    }
-    const project = findProjectFromPath(tree, directory);
-    let fileName = extractedName;
-    let fileExtension = options.fileExtension ?? 'ts';
-    const allowedFileExtensions = options.allowedFileExtensions ?? DEFAULT_ALLOWED_FILE_EXTENSIONS;
-    const fileExtensionRegex = new RegExp(`\\.(${allowedFileExtensions.join('|')})$`);
-    const fileExtensionMatch = fileName.match(fileExtensionRegex);
-    if (fileExtensionMatch) {
-        fileExtension = fileExtensionMatch[1];
-        fileName = fileName.replace(fileExtensionRegex, '');
-        extractedName = fileName;
-    }
-    else if (options.suffix) {
-        fileName = `${fileName}${options.suffixSeparator ?? '.'}${options.suffix}`;
-    }
-    const filePath = (0, devkit_exports_1.joinPathFragments)(directory, `${fileName}.${fileExtension}`);
-    const fileExtensionType = getFileExtensionType(fileExtension);
-    validateFileExtension(fileExtension, allowedFileExtensions, options.js, options.jsOptionName);
-    return {
-        artifactName: options.name ?? extractedName,
+    const fileExtension = options.fileExtension ?? 'ts';
+    const { name: extractedName, directory: extractedDirectory } = extractNameAndDirectoryFromName(options.name);
+    if (extractedDirectory && directory) {
+        throw new Error(`You can't specify both a directory (${options.directory}) and a name with a directory path (${options.name}). ` +
+            `Please specify either a directory or a name with a directory path.`);
+    }
+    const asProvidedOptions = getAsProvidedOptions(tree, {
+        ...options,
+        directory: directory ?? extractedDirectory,
+        fileExtension,
+        name: extractedName,
+    });
+    if (!options.project) {
+        validateResolvedProject(tree, asProvidedOptions.project, options, asProvidedOptions.directory);
+    }
+    if (options.nameAndDirectoryFormat === 'as-provided') {
+        return {
+            'as-provided': asProvidedOptions,
+            derived: undefined,
+        };
+    }
+    if (options.disallowPathInNameForDerived && options.name.includes('/')) {
+        if (!options.nameAndDirectoryFormat) {
+            devkit_exports_1.output.warn({
+                title: `The provided name "${options.name}" contains a path and this is not supported by the "${options.callingGenerator}" when using the "derived" format.`,
+                bodyLines: [
+                    `The generator will try to generate the ${options.artifactType} using the "as-provided" format at "${asProvidedOptions.filePath}".`,
+                ],
+            });
+            return {
+                'as-provided': asProvidedOptions,
+                derived: undefined,
+            };
+        }
+        throw new Error(`The provided name "${options.name}" contains a path and this is not supported by the "${options.callingGenerator}" when using the "derived" format. ` +
+            `Please provide a name without a path or use the "as-provided" format.`);
+    }
+    const derivedOptions = getDerivedOptions(tree, {
+        ...options,
         directory,
-        fileName,
         fileExtension,
-        fileExtensionType,
-        filePath,
-        project,
+        name: extractedName,
+    }, asProvidedOptions, !options.disallowPathInNameForDerived && extractedDirectory
+        ? extractedDirectory
+        : undefined);
+    return {
+        'as-provided': asProvidedOptions,
+        derived: derivedOptions,
     };
 }
-function validateResolvedProject(project, normalizedDirectory) {
+function getAsProvidedOptions(tree, options) {
+    const relativeCwd = getRelativeCwd();
+    let asProvidedDirectory;
+    if (options.directory) {
+        // append the directory to the current working directory if it doesn't start with it
+        if (options.directory === relativeCwd ||
+            options.directory.startsWith(`${relativeCwd}/`)) {
+            asProvidedDirectory = options.directory;
+        }
+        else {
+            asProvidedDirectory = (0, devkit_exports_1.joinPathFragments)(relativeCwd, options.directory);
+        }
+    }
+    else {
+        asProvidedDirectory = relativeCwd;
+    }
+    const asProvidedProject = findProjectFromPath(tree, asProvidedDirectory);
+    const asProvidedFileName = options.fileName ??
+        (options.suffix ? `${options.name}.${options.suffix}` : options.name);
+    const asProvidedFilePath = (0, devkit_exports_1.joinPathFragments)(asProvidedDirectory, `${asProvidedFileName}.${options.fileExtension}`);
+    return {
+        artifactName: options.name,
+        directory: asProvidedDirectory,
+        fileName: asProvidedFileName,
+        filePath: asProvidedFilePath,
+        project: asProvidedProject,
+    };
+}
+function getDerivedOptions(tree, options, asProvidedOptions, extractedDirectory) {
+    const projects = (0, devkit_exports_1.getProjects)(tree);
+    if (options.project && !projects.has(options.project)) {
+        throw new Error(`The provided project "${options.project}" does not exist! Please provide an existing project name.`);
+    }
+    const projectName = options.project ?? asProvidedOptions.project;
+    const project = projects.get(projectName);
+    const derivedName = options.name;
+    const baseDirectory = options.directory
+        ? (0, names_1.names)(options.directory).fileName
+        : (0, devkit_exports_1.joinPathFragments)(project.sourceRoot ?? (0, devkit_exports_1.joinPathFragments)(project.root, 'src'), project.projectType === 'application' ? 'app' : 'lib', extractedDirectory ?? '');
+    const derivedDirectory = typeof options.derivedDirectory === 'string'
+        ? (0, devkit_exports_1.joinPathFragments)(project.sourceRoot ?? project.root, options.derivedDirectory, options.flat
+            ? ''
+            : options.pascalCaseDirectory
+                ? (0, names_1.names)(derivedName).className
+                : (0, names_1.names)(derivedName).fileName)
+        : options.flat
+            ? (0, devkit_exports_1.normalizePath)(baseDirectory)
+            : (0, devkit_exports_1.joinPathFragments)(baseDirectory, options.pascalCaseDirectory
+                ? (0, names_1.names)(derivedName).className
+                : (0, names_1.names)(derivedName).fileName);
+    if (options.directory &&
+        !isDirectoryUnderProjectRoot(derivedDirectory, project.root)) {
+        if (!options.nameAndDirectoryFormat) {
+            devkit_exports_1.output.warn({
+                title: `The provided directory "${options.directory}" is not under the provided project root "${project.root}".`,
+                bodyLines: [
+                    `The generator will try to generate the ${options.artifactType} using the "as-provided" format.`,
+                    `With the "as-provided" format, the "project" option is ignored and the ${options.artifactType} will be generated at "${asProvidedOptions.filePath}" (<cwd>/<provided directory>).`,
+                ],
+            });
+            return undefined;
+        }
+        throw new Error(`The provided directory "${options.directory}" is not under the provided project root "${project.root}". ` +
+            `Please provide a directory that is under the provided project root or use the "as-provided" format and only provide the directory.`);
+    }
+    let derivedFileName = options.fileName;
+    if (!derivedFileName) {
+        derivedFileName = options.suffix
+            ? `${derivedName}.${options.suffix}`
+            : derivedName;
+        derivedFileName = options.pascalCaseFile
+            ? (0, names_1.names)(derivedFileName).className
+            : (0, names_1.names)(derivedFileName).fileName;
+    }
+    const derivedFilePath = (0, devkit_exports_1.joinPathFragments)(derivedDirectory, `${derivedFileName}.${options.fileExtension}`);
+    return {
+        artifactName: derivedName,
+        directory: derivedDirectory,
+        fileName: derivedFileName,
+        filePath: derivedFilePath,
+        project: projectName,
+    };
+}
+function validateResolvedProject(tree, project, options, normalizedDirectory) {
     if (project) {
         return;
     }
-    throw new Error(`The provided directory resolved relative to the current working directory "${normalizedDirectory}" does not exist under any project root. ` +
+    if (options.directory) {
+        throw new Error(`The provided directory resolved relative to the current working directory "${normalizedDirectory}" does not exist under any project root. ` +
+            `Please make sure to navigate to a location or provide a directory that exists under a project root.`);
+    }
+    throw new Error(`The current working directory "${getRelativeCwd() || '.'}" does not exist under any project root. ` +
         `Please make sure to navigate to a location or provide a directory that exists under a project root.`);
 }
 function findProjectFromPath(tree, path) {
@@ -71,6 +218,15 @@ function findProjectFromPath(tree, path) {
     const projectRootMappings = (0, devkit_internals_1.createProjectRootMappingsFromProjectConfigurations)(projectConfigurations);
     return (0, devkit_internals_1.findProjectForPath)(path, projectRootMappings);
 }
+function isDirectoryUnderProjectRoot(directory, projectRoot) {
+    const normalizedDirectory = (0, devkit_exports_1.joinPathFragments)(devkit_exports_1.workspaceRoot, directory);
+    const normalizedProjectRoot = (0, devkit_exports_1.joinPathFragments)(devkit_exports_1.workspaceRoot, projectRoot).replace(/\/$/, '');
+    return (normalizedDirectory === normalizedProjectRoot ||
+        normalizedDirectory.startsWith(`${normalizedProjectRoot}/`));
+}
+function isTTY() {
+    return !!process.stdout.isTTY && process.env['CI'] !== 'true';
+}
 function getRelativeCwd() {
     return (0, devkit_exports_1.normalizePath)((0, path_1.relative)(devkit_exports_1.workspaceRoot, getCwd()));
 }
@@ -85,39 +241,9 @@ function getCwd() {
         ? process.env.INIT_CWD
         : process.cwd();
 }
-function extractNameAndDirectoryFromPath(path) {
-    // Remove trailing slash
-    path = path.replace(/\/$/, '');
-    const parsedPath = (0, devkit_exports_1.normalizePath)(path).split('/');
-    const name = parsedPath.pop();
-    const directory = parsedPath.join('/');
+function extractNameAndDirectoryFromName(rawName) {
+    const parsedName = (0, devkit_exports_1.normalizePath)(rawName).split('/');
+    const name = parsedName.pop();
+    const directory = parsedName.length ? parsedName.join('/') : undefined;
     return { name, directory };
 }
-function getFileExtensionType(fileExtension) {
-    if (DEFAULT_ALLOWED_JS_FILE_EXTENSIONS.includes(fileExtension)) {
-        return 'js';
-    }
-    if (DEFAULT_ALLOWED_TS_FILE_EXTENSIONS.includes(fileExtension)) {
-        return 'ts';
-    }
-    return 'other';
-}
-function validateFileExtension(fileExtension, allowedFileExtensions, js, jsOptionName) {
-    const fileExtensionType = getFileExtensionType(fileExtension);
-    if (!allowedFileExtensions.includes(fileExtension)) {
-        throw new Error(`The provided file path has an extension (.${fileExtension}) that is not supported by this generator.
-The supported extensions are: ${allowedFileExtensions
-            .map((ext) => `.${ext}`)
-            .join(', ')}.`);
-    }
-    if (js !== undefined) {
-        jsOptionName = jsOptionName ?? 'js';
-        if (js && fileExtensionType === 'ts') {
-            throw new Error(`The provided file path has an extension (.${fileExtension}) that conflicts with the provided "--${jsOptionName}" option.`);
-        }
-        if (!js && fileExtensionType === 'js') {
-            throw new Error(`The provided file path has an extension (.${fileExtension}) that conflicts with the provided "--${jsOptionName}" option.`);
-        }
-    }
-    return fileExtensionType;
-}

package/src/generators/format-files.d.ts

@@ -3,10 +3,4 @@ import { Tree } from 'nx/src/devkit-exports';
  * Formats all the created or updated files using Prettier
  * @param tree - the file system tree
  */
-export declare function formatFiles(tree: Tree, options?: {
-    /**
-     * TODO(v21): Stop sorting tsconfig paths by default, paths are now less common/important
-     * in Nx workspace setups, and the sorting causes comments to be lost.
-     */
-    sortRootTsconfigPaths: boolean;
-}): Promise<void>;
+export declare function formatFiles(tree: Tree): Promise<void>;

package/src/generators/format-files.js

@@ -8,28 +8,13 @@ const devkit_internals_1 = require("nx/src/devkit-internals");
  * Formats all the created or updated files using Prettier
  * @param tree - the file system tree
  */
-async function formatFiles(tree, options = {
-    /**
-     * TODO(v21): Stop sorting tsconfig paths by default, paths are now less common/important
-     * in Nx workspace setups, and the sorting causes comments to be lost.
-     */
-    sortRootTsconfigPaths: true,
-}) {
+async function formatFiles(tree) {
     let prettier;
     try {
         prettier = await Promise.resolve().then(() => require('prettier'));
-        /**
-         * Even after we discovered prettier in node_modules, we need to be sure that the user is intentionally using prettier
-         * before proceeding to format with it.
-         */
-        if (!(0, devkit_internals_1.isUsingPrettierInTree)(tree)) {
-            return;
-        }
     }
     catch { }
-    if (options.sortRootTsconfigPaths) {
-        sortTsConfig(tree);
-    }
+    sortTsConfig(tree);
     if (!prettier)
         return;
     const files = new Set(tree.listChanges().filter((file) => file.type !== 'DELETE'));

package/src/generators/project-name-and-root-utils.d.ts

@@ -1,15 +1,19 @@
-import { type ProjectType, type Tree } from 'nx/src/devkit-exports';
+import { ProjectType, Tree } from 'nx/src/devkit-exports';
+export type ProjectNameAndRootFormat = 'as-provided' | 'derived';
 export type ProjectGenerationOptions = {
-    directory: string;
-    name?: string;
+    name: string;
     projectType: ProjectType;
+    callingGenerator: string | null;
+    directory?: string;
     importPath?: string;
+    projectNameAndRootFormat?: ProjectNameAndRootFormat;
     rootProject?: boolean;
 };
 export type ProjectNameAndRootOptions = {
     /**
      * Normalized full project name, including scope if name was provided with
-     * scope (e.g., `@scope/name`)
+     * scope (e.g., `@scope/name`, only available when `projectNameAndRootFormat`
+     * is `as-provided`).
      */
     projectName: string;
     /**
@@ -31,11 +35,12 @@ export type ProjectNameAndRootOptions = {
     /**
      * Normalized import path for the project.
      */
-    importPath: string;
+    importPath?: string;
 };
-export declare function determineProjectNameAndRootOptions(tree: Tree, options: ProjectGenerationOptions): Promise<ProjectNameAndRootOptions>;
-export declare function resolveImportPath(tree: Tree, projectName: string, projectRoot: string): string;
-export declare function ensureRootProjectName(options: {
-    directory: string;
-    name?: string;
-}, projectType: 'application' | 'library'): Promise<void>;
+export declare function determineProjectNameAndRootOptions(tree: Tree, options: ProjectGenerationOptions): Promise<ProjectNameAndRootOptions & {
+    projectNameAndRootFormat: ProjectNameAndRootFormat;
+}>;
+/**
+ * Function for setting cwd during testing
+ */
+export declare function setCwd(path: string): void;