@nx/devkit 17.0.2 → 17.0.4

package/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017-2023 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

@@ -1,4 +1,9 @@
-<p style="text-align: center;"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx.png" width="600" alt="Nx - Smart, Fast and Extensible Build System"></p>
+<p style="text-align: center;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
+    <img alt="Nx - Smart Monorepos · Fast CI" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
 
 <div style="text-align: center;">
 
@@ -15,9 +20,9 @@
 
 <hr>
 
-# Nx: Smart, Fast and Extensible Build System
+# Nx: Smart Monorepos · Fast CI
 
-Nx is a next generation build system with first class monorepo support and powerful integrations.
+Nx is a build system with built-in tooling and advanced CI capabilities. It helps you maintain and scale monorepos, both locally and on CI.
 
 This package contains a set of utilities for creating Nx plugins.
 
@@ -59,5 +64,5 @@ npx nx@latest init
 - [Blog Posts About Nx](https://blog.nrwl.io/nx/home)
 
 <p style="text-align: center;"><a href="https://nx.dev/#learning-materials" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-courses-and-videos.svg" 
-width="100%" alt="Nx - Smart, Fast and Extensible Build System"></a></p>
+width="100%" alt="Nx - Smart Monorepos · Fast CI"></a></p>
 

package/nx.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireNx = void 0;
-// After Nx v18, this can be removed and replaced with either:
+// After Nx v19, this can be removed and replaced with either:
 // - import {} from 'nx/src/devkit-exports'
 // - import {} from 'nx/src/devkit-internals'
 function requireNx() {
@@ -9,7 +9,7 @@ function requireNx() {
     try {
         result = {
             ...result,
-            // Remove in Nx v18, devkit should not support Nx v16.0.2 at that point.
+            // Remove in Nx v19, devkit should not support Nx v16.0.2 at that point.
             ...require('nx/src/devkit-internals'),
         };
     }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@nx/devkit",
-  "version": "17.0.2",
+  "version": "17.0.4",
   "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.",
+  "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": {
     "type": "git",
     "url": "https://github.com/nrwl/nx.git",
@@ -33,8 +33,9 @@
     "ignore": "^5.0.4",
     "tmp": "~0.2.1",
     "tslib": "^2.3.0",
-    "semver": "7.5.3",
-    "@nrwl/devkit": "17.0.2"
+    "semver": "^7.5.3",
+    "yargs-parser": "21.1.1",
+    "@nrwl/devkit": "17.0.4"
   },
   "peerDependencies": {
     "nx": ">= 16 <= 18"

package/public-api.d.ts

@@ -18,7 +18,7 @@ export { generateFiles } from './src/generators/generate-files';
 /**
  * @category Generators
  */
-export { toJS } from './src/generators/to-js';
+export { toJS, ToJSOptions } from './src/generators/to-js';
 /**
  * @category Generators
  */

package/src/executors/parse-target-string.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.targetToTargetString = exports.parseTargetString = void 0;
 const nx_1 = require("../../nx");
 let { readCachedProjectGraph, splitTarget, splitByColons } = (0, nx_1.requireNx)();
-// TODO: Remove this in Nx 18 when Nx 16.7.0 is no longer supported
+// TODO: Remove this in Nx 19 when Nx 16.7.0 is no longer supported
 splitTarget = splitTarget ?? require('nx/src/utils/split-target').splitTarget;
 splitByColons =
     splitByColons ?? ((s) => s.split(':'));
@@ -22,7 +22,8 @@ function parseTargetString(targetString, projectGraphOrCtx) {
     const [maybeProject] = splitByColons(targetString);
     if (!projectGraph.nodes[maybeProject] &&
         projectGraphOrCtx &&
-        'projectName' in projectGraphOrCtx) {
+        'projectName' in projectGraphOrCtx &&
+        maybeProject !== projectGraphOrCtx.projectName) {
         targetString = `${projectGraphOrCtx.projectName}:${targetString}`;
     }
     const [project, target, configuration] = splitTarget(targetString, projectGraph);

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

@@ -4,7 +4,7 @@ exports.readTargetOptions = void 0;
 const nx_1 = require("../../nx");
 const path_1 = require("path");
 let { Workspaces, getExecutorInformation, calculateDefaultProjectName, combineOptionsForExecutor, } = (0, nx_1.requireNx)();
-// TODO: Remove this in Nx 18 when Nx 16.7.0 is no longer supported
+// TODO: Remove this in Nx 19 when Nx 16.7.0 is no longer supported
 combineOptionsForExecutor =
     combineOptionsForExecutor ??
         require('nx/src/utils/params').combineOptionsForExecutor;
@@ -19,16 +19,19 @@ function readTargetOptions({ project, target, configuration }, context) {
         throw new Error(`Unable to find project ${project}`);
     }
     const targetConfiguration = projectConfiguration.targets[target];
-    // TODO(v18): remove Workspaces.
+    if (!targetConfiguration) {
+        throw new Error(`Unable to find target ${target} for project ${project}`);
+    }
+    // TODO(v19): remove Workspaces.
     const ws = new Workspaces(context.root);
     const [nodeModule, executorName] = targetConfiguration.executor.split(':');
     const { schema } = getExecutorInformation
-        ? getExecutorInformation(nodeModule, executorName, context.root)
-        : // TODO(v18): remove readExecutor. This is to be backwards compatible with Nx 16.5 and below.
+        ? getExecutorInformation(nodeModule, executorName, context.root, context.projectsConfigurations?.projects ?? context.workspace.projects)
+        : // TODO(v19): remove readExecutor. This is to be backwards compatible with Nx 16.5 and below.
             ws.readExecutor(nodeModule, executorName);
     const defaultProject = calculateDefaultProjectName
         ? calculateDefaultProjectName(context.cwd, context.root, { version: 2, projects: context.projectsConfigurations.projects }, context.nxJsonConfiguration)
-        : // TODO(v18): remove calculateDefaultProjectName. This is to be backwards compatible with Nx 16.5 and below.
+        : // TODO(v19): remove calculateDefaultProjectName. This is to be backwards compatible with Nx 16.5 and below.
             ws.calculateDefaultProjectName(context.cwd, { version: 2, projects: context.projectsConfigurations.projects }, context.nxJsonConfiguration);
     return combineOptionsForExecutor({}, configuration ?? targetConfiguration.defaultConfiguration ?? '', targetConfiguration, schema, defaultProject, (0, path_1.relative)(context.root, context.cwd));
 }

package/src/generators/add-build-target-defaults.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from 'nx/src/devkit-exports';
+export declare function addBuildTargetDefaults(tree: Tree, executorName: string, buildTargetName?: string): void;

package/src/generators/add-build-target-defaults.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addBuildTargetDefaults = void 0;
+const nx_1 = require("../../nx");
+const { readNxJson, updateNxJson } = (0, nx_1.requireNx)();
+function addBuildTargetDefaults(tree, executorName, buildTargetName = 'build') {
+    const nxJson = readNxJson(tree);
+    nxJson.targetDefaults ??= {};
+    nxJson.targetDefaults[executorName] ??= {
+        cache: true,
+        dependsOn: [`^${buildTargetName}`],
+        inputs: nxJson.namedInputs && 'production' in nxJson.namedInputs
+            ? ['production', '^production']
+            : ['default', '^default'],
+    };
+    updateNxJson(tree, nxJson);
+}
+exports.addBuildTargetDefaults = addBuildTargetDefaults;

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

@@ -48,13 +48,13 @@ async function determineFormat(formats, options) {
                 name: derivedSelectedValue,
             },
         ],
-        initial: 'as-provided',
+        initial: 0,
     }).then(({ format }) => format === asProvidedSelectedValue ? 'as-provided' : 'derived');
     return result;
 }
 function logDeprecationMessage(options, formats) {
     logger.warn(`
-In Nx 18, generating a ${options.artifactType} will no longer support providing a project and deriving the directory.
+In Nx 19, 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.
@@ -116,9 +116,20 @@ function getNameAndDirectoryOptionFormats(tree, options) {
 }
 function getAsProvidedOptions(tree, options) {
     const relativeCwd = getRelativeCwd();
-    const asProvidedDirectory = options.directory
-        ? joinPathFragments(relativeCwd, options.directory)
-        : relativeCwd;
+    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 = joinPathFragments(relativeCwd, options.directory);
+        }
+    }
+    else {
+        asProvidedDirectory = relativeCwd;
+    }
     const asProvidedProject = findProjectFromPath(tree, asProvidedDirectory);
     const asProvidedFileName = options.fileName ??
         (options.suffix ? `${options.name}.${options.suffix}` : options.name);

package/src/generators/format-files.js

@@ -4,7 +4,7 @@ exports.formatFiles = void 0;
 const path = require("path");
 const nx_1 = require("../../nx");
 let { updateJson, readJson, sortObjectByKeys } = (0, nx_1.requireNx)();
-// TODO: Remove this in Nx 18 when Nx 16.7.0 is no longer supported
+// TODO: Remove this in Nx 19 when Nx 16.7.0 is no longer supported
 sortObjectByKeys =
     sortObjectByKeys ?? require('nx/src/utils/object-sort').sortObjectByKeys;
 /**

package/src/generators/project-name-and-root-utils.js

@@ -6,15 +6,18 @@ const path_1 = require("path");
 const nx_1 = require("../../nx");
 const get_workspace_layout_1 = require("../utils/get-workspace-layout");
 const names_1 = require("../utils/names");
-const { joinPathFragments, normalizePath, logger, readJson, stripIndents, workspaceRoot, } = (0, nx_1.requireNx)();
-const deprecationWarning = stripIndents `
-    In Nx 18, generating projects will no longer derive the name and root.
-    Please provide the exact project name and root in the future.`;
+const { joinPathFragments, logger, normalizePath, output, readJson, stripIndents, workspaceRoot, } = (0, nx_1.requireNx)();
 async function determineProjectNameAndRootOptions(tree, options) {
+    if (!options.projectNameAndRootFormat &&
+        (process.env.NX_INTERACTIVE !== 'true' || !isTTY())) {
+        options.projectNameAndRootFormat = 'derived';
+    }
     validateName(options.name, options.projectNameAndRootFormat);
     const formats = getProjectNameAndRootFormats(tree, options);
-    const format = options.projectNameAndRootFormat ??
-        (await determineFormat(tree, formats, options.callingGenerator));
+    const format = options.projectNameAndRootFormat ?? (await determineFormat(formats));
+    if (format === 'derived' && options.callingGenerator) {
+        logDeprecationMessage(options.callingGenerator, formats);
+    }
     return {
         ...formats[format],
         projectNameAndRootFormat: format,
@@ -41,16 +44,17 @@ function validateName(name, projectNameAndRootFormat) {
         throw new Error(`The project name should match the pattern "${pattern}". The provided value "${name}" does not match.`);
     }
 }
-function getExample(callingGenerator, formats) {
-    return `Example: nx g ${callingGenerator} ${formats['as-provided'].projectName} --directory ${formats['as-provided'].projectRoot}`;
+function logDeprecationMessage(callingGenerator, formats) {
+    logger.warn(stripIndents `
+    In Nx 19, generating projects will no longer derive the name and root.
+    Please provide the exact project name and root in the future.
+    Example: nx g ${callingGenerator} ${formats['derived'].projectName} --directory ${formats['derived'].projectRoot}
+  `);
 }
-async function determineFormat(tree, formats, callingGenerator) {
+async function determineFormat(formats) {
     if (!formats.derived) {
         return 'as-provided';
     }
-    if (process.env.NX_INTERACTIVE !== 'true' || !isTTY()) {
-        return 'derived';
-    }
     const asProvidedDescription = `As provided:
     Name: ${formats['as-provided'].projectName}
     Root: ${formats['as-provided'].projectRoot}`;
@@ -76,115 +80,156 @@ async function determineFormat(tree, formats, callingGenerator) {
                 name: derivedSelectedValue,
             },
         ],
-        initial: 'as-provided',
+        initial: 0,
     }).then(({ format }) => format === asProvidedSelectedValue ? 'as-provided' : 'derived');
-    if (result === 'derived' && callingGenerator) {
-        const example = getExample(callingGenerator, formats);
-        logger.warn(deprecationWarning + '\n' + example);
-    }
     return result;
 }
 function getProjectNameAndRootFormats(tree, options) {
     const directory = options.directory
         ? normalizePath(options.directory.replace(/^\.?\//, ''))
         : undefined;
-    const asProvidedProjectName = options.name;
-    let asProvidedProjectDirectory;
-    const relativeCwd = normalizePath((0, path_1.relative)(workspaceRoot, getCwd())).replace(/\/$/, '');
-    if (directory) {
+    const { name: asProvidedParsedName, directory: asProvidedParsedDirectory } = parseNameForAsProvided(options.name);
+    if (asProvidedParsedDirectory && 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 ?? asProvidedParsedDirectory,
+        name: asProvidedParsedName,
+    });
+    if (options.projectNameAndRootFormat === 'as-provided') {
+        return {
+            'as-provided': asProvidedOptions,
+            derived: undefined,
+        };
+    }
+    if (asProvidedOptions.projectName.startsWith('@')) {
+        if (!options.projectNameAndRootFormat) {
+            output.warn({
+                title: `The provided name "${options.name}" contains a scoped project name and this is not supported by the "${options.callingGenerator}" when using the "derived" format.`,
+                bodyLines: [
+                    `The generator will try to generate the project "${asProvidedOptions.projectName}" using the "as-provided" format at "${asProvidedOptions.projectRoot}".`,
+                ],
+            });
+            return {
+                'as-provided': asProvidedOptions,
+                derived: undefined,
+            };
+        }
+        throw new Error(`The provided name "${options.name}" contains a scoped project name and this is not supported by the "${options.callingGenerator}" when using the "derived" format. ` +
+            `Please provide a name without "@" or use the "as-provided" format.`);
+    }
+    const { name: derivedParsedName, directory: derivedParsedDirectory } = parseNameForDerived(options.name);
+    const derivedOptions = getDerivedOptions(tree, {
+        ...options,
+        directory: directory ?? derivedParsedDirectory,
+        name: derivedParsedName,
+    });
+    return {
+        'as-provided': asProvidedOptions,
+        derived: derivedOptions,
+    };
+}
+function getAsProvidedOptions(tree, options) {
+    let projectSimpleName;
+    let projectFileName;
+    if (options.name.startsWith('@')) {
+        const [_scope, ...rest] = options.name.split('/');
+        projectFileName = rest.join('-');
+        projectSimpleName = rest.pop();
+    }
+    else {
+        projectSimpleName = options.name;
+        projectFileName = options.name;
+    }
+    let projectRoot;
+    const relativeCwd = getRelativeCwd();
+    if (options.directory) {
         // append the directory to the current working directory if it doesn't start with it
-        if (directory === relativeCwd || directory.startsWith(`${relativeCwd}/`)) {
-            asProvidedProjectDirectory = directory;
+        if (options.directory === relativeCwd ||
+            options.directory.startsWith(`${relativeCwd}/`)) {
+            projectRoot = options.directory;
         }
         else {
-            asProvidedProjectDirectory = joinPathFragments(relativeCwd, directory);
+            projectRoot = joinPathFragments(relativeCwd, options.directory);
         }
     }
     else if (options.rootProject) {
-        asProvidedProjectDirectory = '.';
+        projectRoot = '.';
     }
     else {
-        asProvidedProjectDirectory = relativeCwd;
+        projectRoot = relativeCwd;
         // append the project name to the current working directory if it doesn't end with it
-        if (!relativeCwd.endsWith(asProvidedProjectName) &&
-            !relativeCwd.endsWith(options.name)) {
-            asProvidedProjectDirectory = joinPathFragments(relativeCwd, asProvidedProjectName);
+        if (!relativeCwd.endsWith(options.name)) {
+            projectRoot = joinPathFragments(relativeCwd, options.name);
         }
     }
-    if (asProvidedProjectName.startsWith('@')) {
-        const nameWithoutScope = asProvidedProjectName.split('/')[1];
-        return {
-            'as-provided': {
-                projectName: asProvidedProjectName,
-                names: {
-                    projectSimpleName: nameWithoutScope,
-                    projectFileName: nameWithoutScope,
-                },
-                importPath: options.importPath ?? asProvidedProjectName,
-                projectRoot: asProvidedProjectDirectory,
-            },
-        };
-    }
-    let asProvidedImportPath;
-    let npmScope;
+    let importPath = undefined;
     if (options.projectType === 'library') {
-        asProvidedImportPath = options.importPath;
-        if (!asProvidedImportPath) {
-            npmScope = getNpmScope(tree);
-            asProvidedImportPath =
-                asProvidedProjectDirectory === '.'
-                    ? readJson(tree, 'package.json').name ??
-                        getImportPath(npmScope, asProvidedProjectName)
-                    : getImportPath(npmScope, asProvidedProjectName);
+        importPath = options.importPath;
+        if (!importPath) {
+            if (options.name.startsWith('@')) {
+                importPath = options.name;
+            }
+            else {
+                const npmScope = getNpmScope(tree);
+                importPath =
+                    projectRoot === '.'
+                        ? readJson(tree, 'package.json').name ??
+                            getImportPath(npmScope, options.name)
+                        : getImportPath(npmScope, options.name);
+            }
         }
     }
+    return {
+        projectName: options.name,
+        names: {
+            projectSimpleName,
+            projectFileName,
+        },
+        importPath,
+        projectRoot,
+    };
+}
+function getDerivedOptions(tree, options) {
     const name = (0, names_1.names)(options.name).fileName;
-    let { projectDirectory, layoutDirectory } = getDirectories(tree, directory, options.projectType);
-    const derivedProjectDirectoryWithoutLayout = projectDirectory
+    let { projectDirectory, layoutDirectory } = getDirectories(tree, options.directory, options.projectType);
+    const projectDirectoryWithoutLayout = projectDirectory
         ? `${(0, names_1.names)(projectDirectory).fileName}/${name}`
         : options.rootProject
             ? '.'
             : name;
     // the project name uses the directory without the layout directory
-    const derivedProjectName = derivedProjectDirectoryWithoutLayout === '.'
+    const projectName = projectDirectoryWithoutLayout === '.'
         ? name
-        : derivedProjectDirectoryWithoutLayout.replace(/\//g, '-');
-    const derivedSimpleProjectName = name;
-    let derivedProjectDirectory = derivedProjectDirectoryWithoutLayout;
-    if (derivedProjectDirectoryWithoutLayout !== '.') {
+        : projectDirectoryWithoutLayout.replace(/\//g, '-');
+    const projectSimpleName = name;
+    let projectRoot = projectDirectoryWithoutLayout;
+    if (projectDirectoryWithoutLayout !== '.') {
         // prepend the layout directory
-        derivedProjectDirectory = joinPathFragments(layoutDirectory, derivedProjectDirectory);
+        projectRoot = joinPathFragments(layoutDirectory, projectRoot);
     }
-    let derivedImportPath;
+    let importPath;
     if (options.projectType === 'library') {
-        derivedImportPath = options.importPath;
-        if (!derivedImportPath) {
-            derivedImportPath =
-                derivedProjectDirectory === '.'
+        importPath = options.importPath;
+        if (!importPath) {
+            const npmScope = getNpmScope(tree);
+            importPath =
+                projectRoot === '.'
                     ? readJson(tree, 'package.json').name ??
-                        getImportPath(npmScope, derivedProjectName)
-                    : getImportPath(npmScope, derivedProjectDirectoryWithoutLayout);
+                        getImportPath(npmScope, projectName)
+                    : getImportPath(npmScope, projectDirectoryWithoutLayout);
         }
     }
     return {
-        'as-provided': {
-            projectName: asProvidedProjectName,
-            names: {
-                projectSimpleName: asProvidedProjectName,
-                projectFileName: asProvidedProjectName,
-            },
-            importPath: asProvidedImportPath,
-            projectRoot: asProvidedProjectDirectory,
-        },
-        derived: {
-            projectName: derivedProjectName,
-            names: {
-                projectSimpleName: derivedSimpleProjectName,
-                projectFileName: derivedProjectName,
-            },
-            importPath: derivedImportPath,
-            projectRoot: derivedProjectDirectory,
+        projectName,
+        names: {
+            projectSimpleName,
+            projectFileName: projectName,
         },
+        importPath,
+        projectRoot,
     };
 }
 function getDirectories(tree, directory, projectType) {
@@ -218,6 +263,9 @@ function getCwd() {
         ? process.env.INIT_CWD
         : process.cwd();
 }
+function getRelativeCwd() {
+    return normalizePath((0, path_1.relative)(workspaceRoot, getCwd())).replace(/\/$/, '');
+}
 /**
  * Function for setting cwd during testing
  */
@@ -225,3 +273,26 @@ function setCwd(path) {
     process.env.INIT_CWD = (0, path_1.join)(workspaceRoot, path);
 }
 exports.setCwd = setCwd;
+function parseNameForAsProvided(rawName) {
+    const directory = normalizePath(rawName);
+    if (rawName.includes('@')) {
+        const index = directory.lastIndexOf('@');
+        if (index === 0) {
+            return { name: rawName, directory: undefined };
+        }
+        const name = directory.substring(index);
+        return { name, directory };
+    }
+    if (rawName.includes('/')) {
+        const index = directory.lastIndexOf('/');
+        const name = directory.substring(index + 1);
+        return { name, directory };
+    }
+    return { name: rawName, directory: undefined };
+}
+function parseNameForDerived(rawName) {
+    const parsedName = normalizePath(rawName).split('/');
+    const name = parsedName.pop();
+    const directory = parsedName.length ? parsedName.join('/') : undefined;
+    return { name, directory };
+}

package/src/generators/to-js.d.ts

@@ -1,5 +1,11 @@
 import type { Tree } from 'nx/src/generators/tree';
+import type { ScriptTarget, ModuleKind } from 'typescript';
+export type ToJSOptions = {
+    target?: ScriptTarget;
+    module?: ModuleKind;
+    extension: '.js' | '.mjs' | '.cjs';
+};
 /**
  * Rename and transpile any new typescript files created to javascript files
  */
-export declare function toJS(tree: Tree): void;
+export declare function toJS(tree: Tree, options?: ToJSOptions): void;

package/src/generators/to-js.js

@@ -6,17 +6,18 @@ const package_json_1 = require("../utils/package-json");
 /**
  * Rename and transpile any new typescript files created to javascript files
  */
-function toJS(tree) {
-    const { JsxEmit, ScriptTarget, transpile } = (0, package_json_1.ensurePackage)('typescript', versions_1.typescriptVersion);
+function toJS(tree, options) {
+    const { JsxEmit, ScriptTarget, transpile, ModuleKind } = (0, package_json_1.ensurePackage)('typescript', versions_1.typescriptVersion);
     for (const c of tree.listChanges()) {
         if ((c.path.endsWith('.ts') || c.path.endsWith('tsx')) &&
             c.type === 'CREATE') {
             tree.write(c.path, transpile(c.content.toString('utf-8'), {
                 allowJs: true,
                 jsx: JsxEmit.Preserve,
-                target: ScriptTarget.ESNext,
+                target: options?.target ?? ScriptTarget.ESNext,
+                module: options?.module ?? ModuleKind.ESNext,
             }));
-            tree.rename(c.path, c.path.replace(/\.tsx?$/, '.js'));
+            tree.rename(c.path, c.path.replace(/\.tsx?$/, options?.extension ?? '.js'));
         }
     }
 }

package/src/utils/calculate-hash-for-create-nodes.d.ts

@@ -0,0 +1,2 @@
+import type { CreateNodesContext } from 'nx/src/devkit-exports';
+export declare function calculateHashForCreateNodes(projectRoot: string, options: object, context: CreateNodesContext, additionalGlobs?: string[]): string;

package/src/utils/calculate-hash-for-create-nodes.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateHashForCreateNodes = void 0;
+const nx_1 = require("../../nx");
+const path_1 = require("path");
+const { hashWithWorkspaceContext, hashArray, hashObject } = (0, nx_1.requireNx)();
+function calculateHashForCreateNodes(projectRoot, options, context, additionalGlobs = []) {
+    return hashArray([
+        hashWithWorkspaceContext(context.workspaceRoot, [
+            (0, path_1.join)(projectRoot, '**/*'),
+            ...additionalGlobs,
+        ]),
+        hashObject(options),
+    ]);
+}
+exports.calculateHashForCreateNodes = calculateHashForCreateNodes;

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

@@ -0,0 +1,4 @@
+export declare let dynamicImport: Function;
+export declare function loadConfigFile<T extends object = any>(configFilePath: string): Promise<T>;
+export declare function getRootTsConfigPath(): string | null;
+export declare function getRootTsConfigFileName(): string | null;

package/src/utils/config-utils.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRootTsConfigFileName = exports.getRootTsConfigPath = exports.loadConfigFile = exports.dynamicImport = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const nx_1 = require("../../nx");
+const { workspaceRoot, registerTsProject } = (0, nx_1.requireNx)();
+exports.dynamicImport = new Function('modulePath', 'return import(modulePath);');
+async function loadConfigFile(configFilePath) {
+    {
+        let module;
+        if ((0, path_1.extname)(configFilePath) === '.ts') {
+            const siblingFiles = (0, fs_1.readdirSync)((0, path_1.dirname)(configFilePath));
+            const tsConfigPath = siblingFiles.includes('tsconfig.json')
+                ? (0, path_1.join)((0, path_1.dirname)(configFilePath), 'tsconfig.json')
+                : getRootTsConfigPath();
+            if (tsConfigPath) {
+                const unregisterTsProject = registerTsProject(tsConfigPath);
+                try {
+                    module = await load(configFilePath);
+                }
+                finally {
+                    unregisterTsProject();
+                }
+            }
+            else {
+                module = await load(configFilePath);
+            }
+        }
+        else {
+            module = await load(configFilePath);
+        }
+        return module.default ?? module;
+    }
+}
+exports.loadConfigFile = loadConfigFile;
+function getRootTsConfigPath() {
+    const tsConfigFileName = getRootTsConfigFileName();
+    return tsConfigFileName ? (0, path_1.join)(workspaceRoot, tsConfigFileName) : null;
+}
+exports.getRootTsConfigPath = getRootTsConfigPath;
+function getRootTsConfigFileName() {
+    for (const tsConfigName of ['tsconfig.base.json', 'tsconfig.json']) {
+        const pathExists = (0, fs_1.existsSync)((0, path_1.join)(workspaceRoot, tsConfigName));
+        if (pathExists) {
+            return tsConfigName;
+        }
+    }
+    return null;
+}
+exports.getRootTsConfigFileName = getRootTsConfigFileName;
+/**
+ * Load the module after ensuring that the require cache is cleared.
+ */
+async function load(path) {
+    // Clear cache if the path is in the cache
+    if (require.cache[path]) {
+        for (const k of Object.keys(require.cache)) {
+            delete require.cache[k];
+        }
+    }
+    try {
+        // Try using `require` first, which works for CJS modules.
+        // Modules are CJS unless it is named `.mjs` or `package.json` sets type to "module".
+        return require(path);
+    }
+    catch (e) {
+        if (e.code === 'ERR_REQUIRE_ESM') {
+            // If `require` fails to load ESM, try dynamic `import()`.
+            return await (0, exports.dynamicImport)(`${path}?t=${Date.now()}`);
+        }
+        // Re-throw all other errors
+        throw e;
+    }
+}

package/src/utils/convert-nx-executor.js

@@ -14,15 +14,15 @@ function convertNxExecutor(executor) {
         const workspaces = new Workspaces(builderContext.workspaceRoot);
         const nxJsonConfiguration = readNxJsonFromDisk
             ? readNxJsonFromDisk(builderContext.workspaceRoot)
-            : // TODO(v18): remove readNxJson. This is to be backwards compatible with Nx 16.5 and below.
+            : // TODO(v19): remove readNxJson. This is to be backwards compatible with Nx 16.5 and below.
                 workspaces.readNxJson();
         const promise = async () => {
             const projectsConfigurations = retrieveProjectConfigurationsWithAngularProjects
                 ? {
                     version: 2,
-                    projects: await retrieveProjectConfigurationsWithAngularProjects(builderContext.workspaceRoot, nxJsonConfiguration).then((p) => p.projectNodes),
+                    projects: await retrieveProjectConfigurationsWithAngularProjects(builderContext.workspaceRoot, nxJsonConfiguration).then((p) => p.projectNodes ?? p.projects),
                 }
-                : // TODO(v18): remove retrieveProjectConfigurations. This is to be backwards compatible with Nx 16.5 and below.
+                : // TODO(v19): remove retrieveProjectConfigurations. This is to be backwards compatible with Nx 16.5 and below.
                     workspaces.readProjectsConfigurations({
                         _includeProjectsFromAngularJson: true,
                     });

package/src/utils/get-named-inputs.d.ts

@@ -0,0 +1,8 @@
+import type { CreateNodesContext } from 'nx/src/devkit-exports';
+import type { InputDefinition } from 'nx/src/config/workspace-json-project-json';
+/**
+ * Get the named inputs available for a directory
+ */
+export declare function getNamedInputs(directory: string, context: CreateNodesContext): {
+    [inputName: string]: (string | InputDefinition)[];
+};

package/src/utils/get-named-inputs.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNamedInputs = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const nx_1 = require("../../nx");
+const { readJsonFile } = (0, nx_1.requireNx)();
+/**
+ * Get the named inputs available for a directory
+ */
+function getNamedInputs(directory, context) {
+    const projectJsonPath = (0, path_1.join)(directory, 'project.json');
+    const projectJson = (0, fs_1.existsSync)(projectJsonPath)
+        ? readJsonFile(projectJsonPath)
+        : null;
+    const packageJsonPath = (0, path_1.join)(directory, 'package.json');
+    const packageJson = (0, fs_1.existsSync)(packageJsonPath)
+        ? readJsonFile(packageJsonPath)
+        : null;
+    return {
+        ...context.nxJsonConfiguration.namedInputs,
+        ...packageJson?.nx?.namedInputs,
+        ...projectJson?.namedInputs,
+    };
+}
+exports.getNamedInputs = getNamedInputs;

package/src/utils/get-workspace-layout.d.ts

@@ -18,7 +18,7 @@ export declare function getWorkspaceLayout(tree: Tree): {
 /**
  * Experimental
  */
-export declare function extractLayoutDirectory(directory: string): {
-    layoutDirectory: string;
-    projectDirectory: string;
+export declare function extractLayoutDirectory(directory?: string): {
+    layoutDirectory: string | null;
+    projectDirectory?: string;
 };

package/src/utils/invoke-nx-generator.js

@@ -4,7 +4,7 @@ exports.convertNxGenerator = void 0;
 const path_1 = require("path");
 const nx_1 = require("../../nx");
 let { logger, stripIndent } = (0, nx_1.requireNx)();
-// TODO: Remove this in Nx 18 when Nx 16.7.0 is no longer supported
+// TODO: Remove this in Nx 19 when Nx 16.7.0 is no longer supported
 stripIndent = stripIndent ?? require('nx/src/utils/logger').stripIndent;
 class RunCallbackTask {
     constructor(callback) {

package/src/utils/log-show-project-command.d.ts

@@ -0,0 +1 @@
+export declare function logShowProjectCommand(projectName: string): void;

package/src/utils/log-show-project-command.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logShowProjectCommand = void 0;
+const nx_1 = require("../../nx");
+function logShowProjectCommand(projectName) {
+    const { output } = (0, nx_1.requireNx)();
+    output.log({
+        title: `👀 View Details of ${projectName}`,
+        bodyLines: [
+            `Run "nx show project ${projectName} --web" to view details about this project.`,
+        ],
+    });
+}
+exports.logShowProjectCommand = logShowProjectCommand;

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

@@ -13,9 +13,10 @@ import type { GeneratorCallback } from 'nx/src/config/misc-interfaces';
  * @param dependencies Dependencies to be added to the dependencies section of package.json
  * @param devDependencies Dependencies to be added to the devDependencies section of package.json
  * @param packageJsonPath Path to package.json
+ * @param keepExistingVersions If true, prevents existing dependencies from being bumped to newer versions
  * @returns Callback to install dependencies only if necessary, no-op otherwise
  */
-export declare function addDependenciesToPackageJson(tree: Tree, dependencies: Record<string, string>, devDependencies: Record<string, string>, packageJsonPath?: string): GeneratorCallback;
+export declare function addDependenciesToPackageJson(tree: Tree, dependencies: Record<string, string>, devDependencies: Record<string, string>, packageJsonPath?: string, keepExistingVersions?: boolean): GeneratorCallback;
 /**
  * Remove Dependencies and Dev Dependencies from package.json
  *

package/src/utils/package-json.js

@@ -86,9 +86,10 @@ function updateExistingDependenciesVersion(dependencies, existingDependencies =
  * @param dependencies Dependencies to be added to the dependencies section of package.json
  * @param devDependencies Dependencies to be added to the devDependencies section of package.json
  * @param packageJsonPath Path to package.json
+ * @param keepExistingVersions If true, prevents existing dependencies from being bumped to newer versions
  * @returns Callback to install dependencies only if necessary, no-op otherwise
  */
-function addDependenciesToPackageJson(tree, dependencies, devDependencies, packageJsonPath = 'package.json') {
+function addDependenciesToPackageJson(tree, dependencies, devDependencies, packageJsonPath = 'package.json', keepExistingVersions) {
     const currentPackageJson = readJson(tree, packageJsonPath);
     /** Dependencies to install that are not met in dev dependencies */
     let filteredDependencies = filterExistingDependencies(dependencies, currentPackageJson.devDependencies);
@@ -96,6 +97,7 @@ function addDependenciesToPackageJson(tree, dependencies, devDependencies, packa
     let filteredDevDependencies = filterExistingDependencies(devDependencies, currentPackageJson.dependencies);
     // filtered dependencies should consist of:
     // - dependencies of the same type that are not present
+    // by default, filtered dependencies also include these (unless keepExistingVersions is true):
     // - dependencies of the same type that have greater version
     // - specified dependencies of the other type that have greater version and are already installed as current type
     filteredDependencies = {
@@ -106,8 +108,14 @@ function addDependenciesToPackageJson(tree, dependencies, devDependencies, packa
         ...updateExistingDependenciesVersion(filteredDevDependencies, currentPackageJson.devDependencies),
         ...updateExistingAltDependenciesVersion(dependencies, currentPackageJson.devDependencies),
     };
-    filteredDependencies = removeLowerVersions(filteredDependencies, currentPackageJson.dependencies);
-    filteredDevDependencies = removeLowerVersions(filteredDevDependencies, currentPackageJson.devDependencies);
+    if (keepExistingVersions) {
+        filteredDependencies = removeExistingDependencies(filteredDependencies, currentPackageJson.dependencies);
+        filteredDevDependencies = removeExistingDependencies(filteredDevDependencies, currentPackageJson.devDependencies);
+    }
+    else {
+        filteredDependencies = removeLowerVersions(filteredDependencies, currentPackageJson.dependencies);
+        filteredDevDependencies = removeLowerVersions(filteredDevDependencies, currentPackageJson.devDependencies);
+    }
     if (requiresAddingOfPackages(currentPackageJson, filteredDependencies, filteredDevDependencies)) {
         updateJson(tree, packageJsonPath, (json) => {
             json.dependencies = {
@@ -134,11 +142,19 @@ exports.addDependenciesToPackageJson = addDependenciesToPackageJson;
  **/
 function removeLowerVersions(incomingDeps, existingDeps) {
     return Object.keys(incomingDeps).reduce((acc, d) => {
-        if (existingDeps?.[d] &&
-            !isIncomingVersionGreater(incomingDeps[d], existingDeps[d])) {
-            return acc;
+        if (!existingDeps?.[d] ||
+            isIncomingVersionGreater(incomingDeps[d], existingDeps[d])) {
+            acc[d] = incomingDeps[d];
+        }
+        return acc;
+    }, {});
+}
+function removeExistingDependencies(incomingDeps, existingDeps) {
+    return Object.keys(incomingDeps).reduce((acc, d) => {
+        if (!existingDeps?.[d]) {
+            acc[d] = incomingDeps[d];
         }
-        return { ...acc, [d]: incomingDeps[d] };
+        return acc;
     }, {});
 }
 /**
@@ -273,7 +289,7 @@ function ensurePackage(pkgOrTree, requiredVersionOrPackage, maybeRequiredVersion
         }
     }
     if (process.env.NX_DRY_RUN && process.env.NX_DRY_RUN !== 'false') {
-        throw new Error('NOTE: This generator does not support --dry-run. If you are running this in Nx Console, it should execute fine once you hit the "Run" button.\n');
+        throw new Error('NOTE: This generator does not support --dry-run. If you are running this in Nx Console, it should execute fine once you hit the "Generate" button.\n');
     }
     const { dir: tempDir } = createTempNpmDirectory?.() ?? {
         dir: (0, tmp_1.dirSync)().name,

package/src/utils/replace-project-configuration-with-plugin.d.ts

@@ -0,0 +1,2 @@
+import type { Tree, CreateNodes } from 'nx/src/devkit-exports';
+export declare function replaceProjectConfigurationsWithPlugin<T = unknown>(tree: Tree, rootMappings: Map<string, string>, pluginPath: string, createNodes: CreateNodes<T>, pluginOptions: T): Promise<void>;

package/src/utils/replace-project-configuration-with-plugin.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceProjectConfigurationsWithPlugin = void 0;
+const nx_1 = require("../../nx");
+const { readNxJson, updateNxJson, glob, hashObject, findProjectForPath, readProjectConfiguration, updateProjectConfiguration, } = (0, nx_1.requireNx)();
+async function replaceProjectConfigurationsWithPlugin(tree, rootMappings, pluginPath, createNodes, pluginOptions) {
+    const nxJson = readNxJson(tree);
+    const hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string' ? p === pluginPath : p.plugin === pluginPath);
+    if (hasPlugin) {
+        return;
+    }
+    nxJson.plugins ??= [];
+    nxJson.plugins.push({
+        plugin: pluginPath,
+        options: pluginOptions,
+    });
+    updateNxJson(tree, nxJson);
+    const [pluginGlob, createNodesFunction] = createNodes;
+    const configFiles = glob(tree, [pluginGlob]);
+    for (const configFile of configFiles) {
+        try {
+            const projectName = findProjectForPath(configFile, rootMappings);
+            const projectConfig = readProjectConfiguration(tree, projectName);
+            const nodes = await createNodesFunction(configFile, pluginOptions, {
+                workspaceRoot: tree.root,
+                nxJsonConfiguration: readNxJson(tree),
+                configFiles,
+            });
+            const node = nodes.projects[Object.keys(nodes.projects)[0]];
+            for (const [targetName, targetConfig] of Object.entries(node.targets)) {
+                const targetFromProjectConfig = projectConfig.targets[targetName];
+                if (targetFromProjectConfig?.executor !== targetConfig.executor) {
+                    continue;
+                }
+                const targetFromCreateNodes = node.targets[targetName];
+                removeConfigurationDefinedByPlugin(targetName, targetFromProjectConfig, targetFromCreateNodes, projectConfig);
+            }
+            updateProjectConfiguration(tree, projectName, projectConfig);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+}
+exports.replaceProjectConfigurationsWithPlugin = replaceProjectConfigurationsWithPlugin;
+function removeConfigurationDefinedByPlugin(targetName, targetFromProjectConfig, targetFromCreateNodes, projectConfig) {
+    // Executor
+    delete targetFromProjectConfig.executor;
+    // Default Configuration
+    if (targetFromProjectConfig.defaultConfiguration ===
+        targetFromCreateNodes.defaultConfiguration) {
+        delete targetFromProjectConfig.defaultConfiguration;
+    }
+    // Cache
+    if (targetFromProjectConfig.cache === targetFromCreateNodes.cache) {
+        delete targetFromProjectConfig.cache;
+    }
+    // Depends On
+    if (targetFromProjectConfig.dependsOn &&
+        shouldRemoveArrayProperty(targetFromProjectConfig.dependsOn, targetFromCreateNodes.dependsOn)) {
+        delete targetFromProjectConfig.dependsOn;
+    }
+    // Outputs
+    if (targetFromProjectConfig.outputs &&
+        shouldRemoveArrayProperty(targetFromProjectConfig.outputs, targetFromCreateNodes.outputs)) {
+        delete targetFromProjectConfig.outputs;
+    }
+    // Inputs
+    if (targetFromProjectConfig.inputs &&
+        shouldRemoveArrayProperty(targetFromProjectConfig.inputs, targetFromCreateNodes.inputs)) {
+        delete targetFromProjectConfig.inputs;
+    }
+    // Options
+    for (const [optionName, optionValue] of Object.entries(targetFromProjectConfig.options ?? {})) {
+        if (equals(targetFromCreateNodes.options[optionName], optionValue)) {
+            delete targetFromProjectConfig.options[optionName];
+        }
+    }
+    if (Object.keys(targetFromProjectConfig.options).length === 0) {
+        delete targetFromProjectConfig.options;
+    }
+    // Configurations
+    for (const [configName, configOptions] of Object.entries(targetFromProjectConfig.configurations ?? {})) {
+        for (const [optionName, optionValue] of Object.entries(configOptions)) {
+            if (targetFromCreateNodes.configurations?.[configName]?.[optionName] ===
+                optionValue) {
+                delete targetFromProjectConfig.configurations[configName][optionName];
+            }
+        }
+        if (Object.keys(configOptions).length === 0) {
+            delete targetFromProjectConfig.configurations[configName];
+        }
+    }
+    if (Object.keys(targetFromProjectConfig.configurations ?? {}).length === 0) {
+        delete targetFromProjectConfig.configurations;
+    }
+    if (Object.keys(targetFromProjectConfig).length === 0) {
+        delete projectConfig.targets[targetName];
+    }
+}
+function equals(a, b) {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((v, i) => v === b[i]);
+    }
+    if (typeof a === 'object' && typeof b === 'object') {
+        return hashObject(a) === hashObject(b);
+    }
+    return a === b;
+}
+function shouldRemoveArrayProperty(arrayValuesFromProjectConfiguration, arrayValuesFromCreateNodes) {
+    const setOfArrayValuesFromProjectConfiguration = new Set(arrayValuesFromProjectConfiguration);
+    loopThroughArrayValuesFromCreateNodes: for (const arrayValueFromCreateNodes of arrayValuesFromCreateNodes) {
+        if (typeof arrayValueFromCreateNodes === 'string') {
+            if (!setOfArrayValuesFromProjectConfiguration.has(arrayValueFromCreateNodes)) {
+                // If the inputs from the project configuration is missing an input from createNodes it was removed
+                return false;
+            }
+            else {
+                setOfArrayValuesFromProjectConfiguration.delete(arrayValueFromCreateNodes);
+            }
+        }
+        else {
+            for (const arrayValue of setOfArrayValuesFromProjectConfiguration.values()) {
+                if (typeof arrayValue !== 'string' &&
+                    hashObject(arrayValue) === hashObject(arrayValueFromCreateNodes)) {
+                    setOfArrayValuesFromProjectConfiguration.delete(arrayValue);
+                    // Continue the outer loop, breaking out of this loop
+                    continue loopThroughArrayValuesFromCreateNodes;
+                }
+            }
+            // If an input was not matched, that means the input was removed
+            return false;
+        }
+    }
+    // If there are still inputs in the project configuration, they have added additional inputs
+    return setOfArrayValuesFromProjectConfiguration.size === 0;
+}

package/src/utils/update-package-scripts.d.ts

@@ -0,0 +1,2 @@
+import type { CreateNodes, Tree } from 'nx/src/devkit-exports';
+export declare function updatePackageScripts(tree: Tree, createNodesTuple: CreateNodes): Promise<void>;

package/src/utils/update-package-scripts.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePackageScripts = void 0;
+const path_1 = require("path");
+const yargs = require("yargs-parser");
+const nx_1 = require("../../nx");
+const { glob, readJson, readNxJson, workspaceRoot, writeJson } = (0, nx_1.requireNx)();
+async function updatePackageScripts(tree, createNodesTuple) {
+    const nxJson = readNxJson(tree);
+    const [pattern, createNodes] = createNodesTuple;
+    const matchingFiles = glob(tree, [pattern]);
+    for (const file of matchingFiles) {
+        const projectRoot = getProjectRootFromConfigFile(file);
+        await processProject(tree, projectRoot, file, createNodes, nxJson, matchingFiles);
+    }
+}
+exports.updatePackageScripts = updatePackageScripts;
+async function processProject(tree, projectRoot, projectConfigurationFile, createNodesFunction, nxJsonConfiguration, configFiles) {
+    const packageJsonPath = `${projectRoot}/package.json`;
+    if (!tree.exists(packageJsonPath)) {
+        return;
+    }
+    const packageJson = readJson(tree, packageJsonPath);
+    if (!packageJson.scripts || !Object.keys(packageJson.scripts).length) {
+        return;
+    }
+    const result = await createNodesFunction(projectConfigurationFile, {}, {
+        nxJsonConfiguration,
+        workspaceRoot,
+        configFiles,
+    });
+    const targetCommands = getInferredTargetCommands(result);
+    if (!targetCommands.length) {
+        return;
+    }
+    const replacedTargets = new Set();
+    for (const targetCommand of targetCommands) {
+        const { command, target, configuration } = targetCommand;
+        const targetCommandRegex = new RegExp(`(?<=^|&)((?: )*(?:[^&\\r\\n\\s]+ )*)(${command})((?: [^&\\r\\n\\s]+)*(?: )*)(?=$|&)`, 'g');
+        for (const scriptName of Object.keys(packageJson.scripts)) {
+            const script = packageJson.scripts[scriptName];
+            // quick check for exact match within the script
+            if (targetCommandRegex.test(script)) {
+                packageJson.scripts[scriptName] = script.replace(targetCommandRegex, configuration
+                    ? `$1nx ${target} --configuration=${configuration}$3`
+                    : `$1nx ${target}$3`);
+                replacedTargets.add(target);
+            }
+            else {
+                /**
+                 * Parse script and command to handle the following:
+                 * - if command doesn't match script                  => don't replace
+                 * - if command has more args                         => don't replace
+                 * - if command has same args, regardless of order    => replace removing args
+                 * - if command has less args or with different value => replace leaving args
+                 */
+                const parsedCommand = yargs(command, {
+                    configuration: { 'strip-dashed': true },
+                });
+                // this assumes there are no positional args in the command, everything is a command or subcommand
+                const commandCommand = parsedCommand._.join(' ');
+                const commandRegex = new RegExp(`(?<=^|&)((?: )*(?:[^&\\r\\n\\s]+ )*)(${commandCommand})((?: [^&\\r\\n\\s]+)*( )*)(?=$|&)`, 'g');
+                const matches = script.match(commandRegex);
+                if (!matches) {
+                    // the command doesn't match the script, don't replace
+                    continue;
+                }
+                for (const match of matches) {
+                    // parse the matched command within the script
+                    const parsedScript = yargs(match, {
+                        configuration: { 'strip-dashed': true },
+                    });
+                    let hasArgsWithDifferentValues = false;
+                    let scriptHasExtraArgs = false;
+                    let commandHasExtraArgs = false;
+                    for (const [key, value] of Object.entries(parsedCommand)) {
+                        if (key === '_') {
+                            continue;
+                        }
+                        if (parsedScript[key] === undefined) {
+                            commandHasExtraArgs = true;
+                            break;
+                        }
+                        if (parsedScript[key] !== value) {
+                            hasArgsWithDifferentValues = true;
+                        }
+                    }
+                    if (commandHasExtraArgs) {
+                        // the command has extra args, don't replace
+                        continue;
+                    }
+                    for (const key of Object.keys(parsedScript)) {
+                        if (key === '_') {
+                            continue;
+                        }
+                        if (!parsedCommand[key]) {
+                            scriptHasExtraArgs = true;
+                            break;
+                        }
+                    }
+                    if (!hasArgsWithDifferentValues && !scriptHasExtraArgs) {
+                        // they are the same, replace with the command removing the args
+                        packageJson.scripts[scriptName] = packageJson.scripts[scriptName].replace(match, match.replace(commandRegex, configuration
+                            ? `$1nx ${target} --configuration=${configuration}$4`
+                            : `$1nx ${target}$4`));
+                        replacedTargets.add(target);
+                    }
+                    else {
+                        // there are different args or the script has extra args, replace with the command leaving the args
+                        packageJson.scripts[scriptName] = packageJson.scripts[scriptName].replace(match, match.replace(commandRegex, configuration
+                            ? `$1nx ${target} --configuration=${configuration}$3`
+                            : `$1nx ${target}$3`));
+                        replacedTargets.add(target);
+                    }
+                }
+            }
+        }
+    }
+    if (process.env.NX_RUNNING_NX_INIT === 'true') {
+        // running `nx init` so we want to exclude everything by default
+        packageJson.nx ??= {};
+        packageJson.nx.includedScripts = [];
+    }
+    else if (replacedTargets.size) {
+        /**
+         * Running `nx add`. In this case we want to:
+         * - if `includedScripts` is already set: exclude scripts that match inferred targets that were used to replace a script
+         * - if `includedScripts` is not set: set `includedScripts` with all scripts except the ones that match an inferred target that was used to replace a script
+         */
+        const includedScripts = packageJson.nx?.includedScripts ?? Object.keys(packageJson.scripts);
+        const filteredScripts = includedScripts.filter((s) => !replacedTargets.has(s));
+        if (filteredScripts.length !== includedScripts.length) {
+            packageJson.nx ??= {};
+            packageJson.nx.includedScripts = filteredScripts;
+        }
+    }
+    writeJson(tree, packageJsonPath, packageJson);
+}
+function getInferredTargetCommands(result) {
+    const targetCommands = [];
+    for (const project of Object.values(result.projects ?? {})) {
+        for (const [targetName, target] of Object.entries(project.targets ?? {})) {
+            if (target.command) {
+                targetCommands.push({ command: target.command, target: targetName });
+            }
+            else if (target.executor === 'nx:run-commands' &&
+                target.options?.command) {
+                targetCommands.push({
+                    command: target.options.command,
+                    target: targetName,
+                });
+            }
+            if (!target.configurations) {
+                continue;
+            }
+            for (const [configurationName, configuration] of Object.entries(target.configurations)) {
+                if (configuration.command) {
+                    targetCommands.push({
+                        command: configuration.command,
+                        target: targetName,
+                        configuration: configurationName,
+                    });
+                }
+                else if (target.executor === 'nx:run-commands' &&
+                    configuration.options?.command) {
+                    targetCommands.push({
+                        command: configuration.options.command,
+                        target: targetName,
+                        configuration: configurationName,
+                    });
+                }
+            }
+        }
+    }
+    return targetCommands;
+}
+function getProjectRootFromConfigFile(file) {
+    let projectRoot = (0, path_1.dirname)(file);
+    if ((0, path_1.basename)(projectRoot) === '.storybook') {
+        projectRoot = (0, path_1.dirname)(projectRoot);
+    }
+    return projectRoot;
+}

package/src/utils/versions.d.ts

@@ -1 +1 @@
-export declare const typescriptVersion = "~5.1.3";
+export declare const typescriptVersion = "~5.4.2";

package/src/utils/versions.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.typescriptVersion = void 0;
-exports.typescriptVersion = '~5.1.3';
+exports.typescriptVersion = '~5.4.2';