@nx/devkit 17.1.0-beta.0 → 17.1.0-beta.3

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@nx/devkit",
-  "version": "17.1.0-beta.0",
+  "version": "17.1.0-beta.3",
   "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",
@@ -34,7 +34,7 @@
     "tmp": "~0.2.1",
     "tslib": "^2.3.0",
     "semver": "7.5.3",
-    "@nrwl/devkit": "17.1.0-beta.0"
+    "@nrwl/devkit": "17.1.0-beta.3"
   },
   "peerDependencies": {
     "nx": ">= 16 <= 18"

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

@@ -42,7 +42,7 @@ function validateName(name, projectNameAndRootFormat) {
     }
 }
 function getExample(callingGenerator, formats) {
-    return `Example: nx g ${callingGenerator} ${formats['as-provided'].projectName} --directory ${formats['as-provided'].projectRoot}`;
+    return `Example: nx g ${callingGenerator} ${formats['derived'].projectName} --directory ${formats['derived'].projectRoot}`;
 }
 async function determineFormat(tree, formats, callingGenerator) {
     if (!formats.derived) {

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/replace-project-configuration-with-plugin.d.ts

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

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

@@ -0,0 +1,127 @@
+"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)();
+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 = createNodesFunction(configFile, pluginOptions, {
+                workspaceRoot: tree.root,
+                nxJsonConfiguration: readNxJson(tree),
+            });
+            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 (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 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/versions.d.ts

@@ -1 +1 @@
-export declare const typescriptVersion = "~5.1.3";
+export declare const typescriptVersion = "~5.2.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.2.2';