@nx/devkit 19.0.0-beta.1 → 19.0.0-beta.11

package/src/generators/plugin-migrations/plugin-migration-utils.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Iterate through the current target in the project.json and its options comparing it to the target created by the Plugin itself
+ * Delete matching properties from current target.
+ *
+ * _Note: Deletes by reference_
+ *
+ * @example
+ * // Run the plugin to get all the projects
+ * const { projects } = await createNodes[1](
+ *    playwrightConfigPath,
+ *    { targetName, ciTargetName: 'e2e-ci' },
+ *    { workspaceRoot: tree.root, nxJsonConfiguration, configFiles }
+ * );
+ *
+ * // Find the project that matches the one that is being migrated
+ * const createdProject = Object.entries(projects ?? {}).find(
+ *  ([root]) => root === projectFromGraph.data.root
+ * )[1];
+ *
+ * // Get the created TargetConfiguration for the target being migrated
+ * const createdTarget: TargetConfiguration<RunCommandsOptions> =
+ *    createdProject.targets[targetName];
+ *
+ * // Delete specific run-commands options
+ * delete createdTarget.command;
+ * delete createdTarget.options?.cwd;
+ *
+ * // Get the TargetConfiguration for the target being migrated from project.json
+ * const projectConfig = readProjectConfiguration(tree, projectName);
+ * let targetToMigrate = projectConfig.targets[targetName];
+ *
+ * // Merge the target defaults for the executor to the target being migrated
+ * target = mergeTargetConfigurations(targetToMigrate, targetDefaultsForExecutor);
+ *
+ * // Delete executor and any additional options that are no longer necessary
+ * delete target.executor;
+ * delete target.options?.config;
+ *
+ * // Run deleteMatchingProperties to delete further options that match what the plugin creates
+ * deleteMatchingProperties(target, createdTarget);
+ *
+ * // Delete the target if it is now empty, otherwise, set it to the updated TargetConfiguration
+ * if (Object.keys(target).length > 0) {
+ *    projectConfig.targets[targetName] = target;
+ * } else {
+ *    delete projectConfig.targets[targetName];
+ * }
+ *
+ * updateProjectConfiguration(tree, projectName, projectConfig);
+ *
+ * @param targetToMigrate The target from project.json
+ * @param createdTarget The target created by the Plugin
+ */
+export declare function deleteMatchingProperties(targetToMigrate: object, createdTarget: object): void;

package/src/generators/plugin-migrations/plugin-migration-utils.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteMatchingProperties = void 0;
+/**
+ * Iterate through the current target in the project.json and its options comparing it to the target created by the Plugin itself
+ * Delete matching properties from current target.
+ *
+ * _Note: Deletes by reference_
+ *
+ * @example
+ * // Run the plugin to get all the projects
+ * const { projects } = await createNodes[1](
+ *    playwrightConfigPath,
+ *    { targetName, ciTargetName: 'e2e-ci' },
+ *    { workspaceRoot: tree.root, nxJsonConfiguration, configFiles }
+ * );
+ *
+ * // Find the project that matches the one that is being migrated
+ * const createdProject = Object.entries(projects ?? {}).find(
+ *  ([root]) => root === projectFromGraph.data.root
+ * )[1];
+ *
+ * // Get the created TargetConfiguration for the target being migrated
+ * const createdTarget: TargetConfiguration<RunCommandsOptions> =
+ *    createdProject.targets[targetName];
+ *
+ * // Delete specific run-commands options
+ * delete createdTarget.command;
+ * delete createdTarget.options?.cwd;
+ *
+ * // Get the TargetConfiguration for the target being migrated from project.json
+ * const projectConfig = readProjectConfiguration(tree, projectName);
+ * let targetToMigrate = projectConfig.targets[targetName];
+ *
+ * // Merge the target defaults for the executor to the target being migrated
+ * target = mergeTargetConfigurations(targetToMigrate, targetDefaultsForExecutor);
+ *
+ * // Delete executor and any additional options that are no longer necessary
+ * delete target.executor;
+ * delete target.options?.config;
+ *
+ * // Run deleteMatchingProperties to delete further options that match what the plugin creates
+ * deleteMatchingProperties(target, createdTarget);
+ *
+ * // Delete the target if it is now empty, otherwise, set it to the updated TargetConfiguration
+ * if (Object.keys(target).length > 0) {
+ *    projectConfig.targets[targetName] = target;
+ * } else {
+ *    delete projectConfig.targets[targetName];
+ * }
+ *
+ * updateProjectConfiguration(tree, projectName, projectConfig);
+ *
+ * @param targetToMigrate The target from project.json
+ * @param createdTarget The target created by the Plugin
+ */
+function deleteMatchingProperties(targetToMigrate, createdTarget) {
+    for (const key in targetToMigrate) {
+        if (Array.isArray(targetToMigrate[key])) {
+            if (targetToMigrate[key].every((v) => createdTarget[key]?.includes(v)) &&
+                targetToMigrate[key].length === createdTarget[key]?.length) {
+                delete targetToMigrate[key];
+            }
+        }
+        else if (typeof targetToMigrate[key] === 'object' &&
+            typeof createdTarget[key] === 'object') {
+            deleteMatchingProperties(targetToMigrate[key], createdTarget[key]);
+        }
+        else if (targetToMigrate[key] === createdTarget[key]) {
+            delete targetToMigrate[key];
+        }
+        if (typeof targetToMigrate[key] === 'object' &&
+            Object.keys(targetToMigrate[key]).length === 0) {
+            delete targetToMigrate[key];
+        }
+    }
+}
+exports.deleteMatchingProperties = deleteMatchingProperties;

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

@@ -1,5 +1,4 @@
-import type { ProjectType } from 'nx/src/config/workspace-json-project-json';
-import type { Tree } from 'nx/src/generators/tree';
+import { ProjectType, Tree } from 'nx/src/devkit-exports';
 export type ProjectNameAndRootFormat = 'as-provided' | 'derived';
 export type ProjectGenerationOptions = {
     name: string;

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

@@ -3,10 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setCwd = exports.determineProjectNameAndRootOptions = void 0;
 const enquirer_1 = require("enquirer");
 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, logger, normalizePath, output, readJson, stripIndents, workspaceRoot, } = (0, nx_1.requireNx)();
+const devkit_exports_1 = require("nx/src/devkit-exports");
 async function determineProjectNameAndRootOptions(tree, options) {
     if (!options.projectNameAndRootFormat &&
         (process.env.NX_INTERACTIVE !== 'true' || !isTTY())) {
@@ -45,8 +44,8 @@ function validateName(name, projectNameAndRootFormat) {
     }
 }
 function logDeprecationMessage(callingGenerator, formats) {
-    logger.warn(stripIndents `
-    In Nx 19, generating projects will no longer derive the name and root.
+    devkit_exports_1.logger.warn((0, devkit_exports_1.stripIndents) `
+    In Nx 20, 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}
   `);
@@ -86,7 +85,7 @@ async function determineFormat(formats) {
 }
 function getProjectNameAndRootFormats(tree, options) {
     const directory = options.directory
-        ? normalizePath(options.directory.replace(/^\.?\//, ''))
+        ? (0, devkit_exports_1.normalizePath)(options.directory.replace(/^\.?\//, ''))
         : undefined;
     const { name: asProvidedParsedName, directory: asProvidedParsedDirectory } = parseNameForAsProvided(options.name);
     if (asProvidedParsedDirectory && directory) {
@@ -106,7 +105,7 @@ function getProjectNameAndRootFormats(tree, options) {
     }
     if (asProvidedOptions.projectName.startsWith('@')) {
         if (!options.projectNameAndRootFormat) {
-            output.warn({
+            devkit_exports_1.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}".`,
@@ -152,7 +151,7 @@ function getAsProvidedOptions(tree, options) {
             projectRoot = options.directory;
         }
         else {
-            projectRoot = joinPathFragments(relativeCwd, options.directory);
+            projectRoot = (0, devkit_exports_1.joinPathFragments)(relativeCwd, options.directory);
         }
     }
     else if (options.rootProject) {
@@ -162,7 +161,7 @@ function getAsProvidedOptions(tree, options) {
         projectRoot = relativeCwd;
         // append the project name to the current working directory if it doesn't end with it
         if (!relativeCwd.endsWith(options.name)) {
-            projectRoot = joinPathFragments(relativeCwd, options.name);
+            projectRoot = (0, devkit_exports_1.joinPathFragments)(relativeCwd, options.name);
         }
     }
     let importPath = undefined;
@@ -176,7 +175,7 @@ function getAsProvidedOptions(tree, options) {
                 const npmScope = getNpmScope(tree);
                 importPath =
                     projectRoot === '.'
-                        ? readJson(tree, 'package.json').name ??
+                        ? (0, devkit_exports_1.readJson)(tree, 'package.json').name ??
                             getImportPath(npmScope, options.name)
                         : getImportPath(npmScope, options.name);
             }
@@ -208,7 +207,7 @@ function getDerivedOptions(tree, options) {
     let projectRoot = projectDirectoryWithoutLayout;
     if (projectDirectoryWithoutLayout !== '.') {
         // prepend the layout directory
-        projectRoot = joinPathFragments(layoutDirectory, projectRoot);
+        projectRoot = (0, devkit_exports_1.joinPathFragments)(layoutDirectory, projectRoot);
     }
     let importPath;
     if (options.projectType === 'library') {
@@ -217,7 +216,7 @@ function getDerivedOptions(tree, options) {
             const npmScope = getNpmScope(tree);
             importPath =
                 projectRoot === '.'
-                    ? readJson(tree, 'package.json').name ??
+                    ? (0, devkit_exports_1.readJson)(tree, 'package.json').name ??
                         getImportPath(npmScope, projectName)
                     : getImportPath(npmScope, projectDirectoryWithoutLayout);
         }
@@ -245,7 +244,7 @@ function getImportPath(npmScope, name) {
 }
 function getNpmScope(tree) {
     const { name } = tree.exists('package.json')
-        ? readJson(tree, 'package.json')
+        ? (0, devkit_exports_1.readJson)(tree, 'package.json')
         : { name: null };
     return name?.startsWith('@') ? name.split('/')[0].substring(1) : undefined;
 }
@@ -259,22 +258,22 @@ function isTTY() {
  * environment variable (see here: https://docs.npmjs.com/cli/v9/commands/npm-run-script#description).
  */
 function getCwd() {
-    return process.env.INIT_CWD?.startsWith(workspaceRoot)
+    return process.env.INIT_CWD?.startsWith(devkit_exports_1.workspaceRoot)
         ? process.env.INIT_CWD
         : process.cwd();
 }
 function getRelativeCwd() {
-    return normalizePath((0, path_1.relative)(workspaceRoot, getCwd())).replace(/\/$/, '');
+    return (0, devkit_exports_1.normalizePath)((0, path_1.relative)(devkit_exports_1.workspaceRoot, getCwd())).replace(/\/$/, '');
 }
 /**
  * Function for setting cwd during testing
  */
 function setCwd(path) {
-    process.env.INIT_CWD = (0, path_1.join)(workspaceRoot, path);
+    process.env.INIT_CWD = (0, path_1.join)(devkit_exports_1.workspaceRoot, path);
 }
 exports.setCwd = setCwd;
 function parseNameForAsProvided(rawName) {
-    const directory = normalizePath(rawName);
+    const directory = (0, devkit_exports_1.normalizePath)(rawName);
     if (rawName.includes('@')) {
         const index = directory.lastIndexOf('@');
         if (index === 0) {
@@ -291,7 +290,7 @@ function parseNameForAsProvided(rawName) {
     return { name: rawName, directory: undefined };
 }
 function parseNameForDerived(rawName) {
-    const parsedName = normalizePath(rawName).split('/');
+    const parsedName = (0, devkit_exports_1.normalizePath)(rawName).split('/');
     const name = parsedName.pop();
     const directory = parsedName.length ? parsedName.join('/') : undefined;
     return { name, directory };

package/src/generators/run-tasks-in-serial.d.ts

@@ -1,4 +1,4 @@
-import type { GeneratorCallback } from 'nx/src/config/misc-interfaces';
+import type { GeneratorCallback } from 'nx/src/devkit-exports';
 /**
  * Run tasks in serial
  *

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

@@ -1,4 +1,4 @@
-import type { Tree } from 'nx/src/generators/tree';
+import type { Tree } from 'nx/src/devkit-exports';
 import type { ScriptTarget, ModuleKind } from 'typescript';
 export type ToJSOptions = {
     target?: ScriptTarget;

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

@@ -1,4 +1,4 @@
-import type { Tree } from 'nx/src/generators/tree';
+import { Tree } from 'nx/src/devkit-exports';
 export declare function updateTsConfigsToJs(tree: Tree, options: {
     projectRoot: string;
 }): void;

package/src/generators/update-ts-configs-to-js.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateTsConfigsToJs = void 0;
-const nx_1 = require("../../nx");
-const { updateJson } = (0, nx_1.requireNx)();
+const devkit_exports_1 = require("nx/src/devkit-exports");
 function updateTsConfigsToJs(tree, options) {
     let updateConfigPath;
     const paths = {
@@ -19,7 +18,7 @@ function updateTsConfigsToJs(tree, options) {
         }
         throw new Error(`project is missing tsconfig.lib.json or tsconfig.app.json`);
     };
-    updateJson(tree, paths.tsConfig, (json) => {
+    (0, devkit_exports_1.updateJson)(tree, paths.tsConfig, (json) => {
         if (json.compilerOptions) {
             json.compilerOptions.allowJs = true;
         }
@@ -35,7 +34,7 @@ function updateTsConfigsToJs(tree, options) {
     if (projectType === 'application') {
         updateConfigPath = paths.tsConfigApp;
     }
-    updateJson(tree, updateConfigPath, (json) => {
+    (0, devkit_exports_1.updateJson)(tree, updateConfigPath, (json) => {
         json.include = uniq([...json.include, 'src/**/*.js']);
         json.exclude = uniq([
             ...json.exclude,

package/src/generators/visit-not-ignored-files.d.ts

@@ -1,4 +1,4 @@
-import type { Tree } from 'nx/src/generators/tree';
+import type { Tree } from 'nx/src/devkit-exports';
 /**
  * Utility to act on all files in a tree that are not ignored by git.
  */

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

@@ -1,2 +1,2 @@
-import type { Tree } from 'nx/src/generators/tree';
+import type { Tree } from 'nx/src/devkit-exports';
 export default function replacePackage(tree: Tree): Promise<void>;

package/src/migrations/update-16-9-0/migrate-mf-util-usage.d.ts

@@ -1,4 +1,3 @@
-import type { Tree } from 'nx/src/generators/tree';
-import type { GeneratorCallback } from 'nx/src/config/misc-interfaces';
+import { GeneratorCallback, Tree } from 'nx/src/devkit-exports';
 declare const _default: (tree: Tree) => Promise<GeneratorCallback | void>;
 export default _default;

package/src/migrations/update-16-9-0/migrate-mf-util-usage.js

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const visit_not_ignored_files_1 = require("../../generators/visit-not-ignored-files");
 const format_files_1 = require("../../generators/format-files");
-const nx_1 = require("../../../nx");
 const package_json_1 = require("../../utils/package-json");
 const versions_1 = require("../../utils/versions");
-const { readJson } = (0, nx_1.requireNx)();
+const devkit_exports_1 = require("nx/src/devkit-exports");
 let tsModule;
 const MODULE_FEDERATION_PUBLIC_TOKENS = [
     'AdditionalSharedConfig',
@@ -45,7 +44,7 @@ exports.default = async (tree) => {
     });
     if (hasFileToMigrate) {
         await (0, format_files_1.formatFiles)(tree);
-        const pkgJson = readJson(tree, 'package.json');
+        const pkgJson = (0, devkit_exports_1.readJson)(tree, 'package.json');
         const nxVersion = pkgJson.devDependencies?.['nx'] ??
             pkgJson.dependencies?.['nx'] ??
             '17.0.0';

package/src/tasks/install-packages-task.d.ts

@@ -1,5 +1,4 @@
-import type { Tree } from 'nx/src/generators/tree';
-import type { PackageManager } from 'nx/src/utils/package-manager';
+import { PackageManager, Tree } from 'nx/src/devkit-exports';
 /**
  * Runs `npm install` or `yarn install`. It will skip running the install if
  * `package.json` hasn't changed at all or it hasn't changed since the last invocation.

package/src/tasks/install-packages-task.js

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.installPackagesTask = void 0;
 const child_process_1 = require("child_process");
 const path_1 = require("path");
-const nx_1 = require("../../nx");
-const { detectPackageManager, getPackageManagerCommand, joinPathFragments } = (0, nx_1.requireNx)();
+const devkit_exports_1 = require("nx/src/devkit-exports");
 /**
  * Runs `npm install` or `yarn install`. It will skip running the install if
  * `package.json` hasn't changed at all or it hasn't changed since the last invocation.
@@ -12,19 +11,19 @@ const { detectPackageManager, getPackageManagerCommand, joinPathFragments } = (0
  * @param tree - the file system tree
  * @param alwaysRun - always run the command even if `package.json` hasn't changed.
  */
-function installPackagesTask(tree, alwaysRun = false, cwd = '', packageManager = detectPackageManager(cwd)) {
+function installPackagesTask(tree, alwaysRun = false, cwd = '', packageManager = (0, devkit_exports_1.detectPackageManager)(cwd)) {
     if (!tree
         .listChanges()
-        .find((f) => f.path === joinPathFragments(cwd, 'package.json')) &&
+        .find((f) => f.path === (0, devkit_exports_1.joinPathFragments)(cwd, 'package.json')) &&
         !alwaysRun) {
         return;
     }
-    const packageJsonValue = tree.read(joinPathFragments(cwd, 'package.json'), 'utf-8');
+    const packageJsonValue = tree.read((0, devkit_exports_1.joinPathFragments)(cwd, 'package.json'), 'utf-8');
     let storedPackageJsonValue = global['__packageJsonInstallCache__'];
     // Don't install again if install was already executed with package.json
     if (storedPackageJsonValue != packageJsonValue || alwaysRun) {
         global['__packageJsonInstallCache__'] = packageJsonValue;
-        const pmc = getPackageManagerCommand(packageManager);
+        const pmc = (0, devkit_exports_1.getPackageManagerCommand)(packageManager);
         const execSyncOptions = {
             cwd: (0, path_1.join)(tree.root, cwd),
             stdio: process.env.NX_GENERATE_QUIET === 'true' ? 'ignore' : 'inherit',

package/src/utils/add-plugin.d.ts

@@ -1,4 +1,4 @@
-import { type CreateNodes, type ProjectGraph, type Tree } from 'nx/src/devkit-exports';
+import { CreateNodes, ProjectGraph, Tree } from 'nx/src/devkit-exports';
 /**
  * Iterates through various forms of plugin options to find the one which does not conflict with the current graph
 

package/src/utils/add-plugin.js

@@ -2,29 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCombinations = exports.addPlugin = void 0;
 const yargs = require("yargs-parser");
-const nx_1 = require("../../nx");
-const { readJson, writeJson, readNxJson, updateNxJson, retrieveProjectConfigurations, LoadedNxPlugin, ProjectConfigurationsError, } = (0, nx_1.requireNx)();
+const devkit_exports_1 = require("nx/src/devkit-exports");
+const devkit_internals_1 = require("nx/src/devkit-internals");
 /**
  * Iterates through various forms of plugin options to find the one which does not conflict with the current graph
 
  */
 async function addPlugin(tree, graph, pluginName, createNodesTuple, options, shouldUpdatePackageJsonScripts) {
     const graphNodes = Object.values(graph.nodes);
-    const nxJson = readNxJson(tree);
+    const nxJson = (0, devkit_exports_1.readNxJson)(tree);
     let pluginOptions;
     let projConfigs;
     const combinations = generateCombinations(options);
     optionsLoop: for (const _pluginOptions of combinations) {
         pluginOptions = _pluginOptions;
         nxJson.plugins ??= [];
-        if (nxJson.plugins.some((p) => typeof p === 'string' ? p === pluginName : p.plugin === pluginName)) {
+        if (nxJson.plugins.some((p) => typeof p === 'string'
+            ? p === pluginName
+            : p.plugin === pluginName && !p.include)) {
             // Plugin has already been added
             return;
         }
         global.NX_GRAPH_CREATION = true;
         try {
-            projConfigs = await retrieveProjectConfigurations([
-                new LoadedNxPlugin({
+            projConfigs = await (0, devkit_internals_1.retrieveProjectConfigurations)([
+                new devkit_internals_1.LoadedNxPlugin({
                     name: pluginName,
                     createNodes: createNodesTuple,
                 }, {
@@ -35,7 +37,7 @@ async function addPlugin(tree, graph, pluginName, createNodesTuple, options, sho
         }
         catch (e) {
             // Errors are okay for this because we're only running 1 plugin
-            if (e instanceof ProjectConfigurationsError) {
+            if (e instanceof devkit_internals_1.ProjectConfigurationsError) {
                 projConfigs = e.partialProjectConfigurationsResult;
             }
             else {
@@ -65,7 +67,7 @@ async function addPlugin(tree, graph, pluginName, createNodesTuple, options, sho
         plugin: pluginName,
         options: pluginOptions,
     });
-    updateNxJson(tree, nxJson);
+    (0, devkit_exports_1.updateNxJson)(tree, nxJson);
     if (shouldUpdatePackageJsonScripts) {
         updatePackageScripts(tree, projConfigs);
     }
@@ -82,7 +84,7 @@ function processProject(tree, projectRoot, projectConfiguration) {
     if (!tree.exists(packageJsonPath)) {
         return;
     }
-    const packageJson = readJson(tree, packageJsonPath);
+    const packageJson = (0, devkit_exports_1.readJson)(tree, packageJsonPath);
     if (!packageJson.scripts || !Object.keys(packageJson.scripts).length) {
         return;
     }
@@ -173,7 +175,7 @@ function processProject(tree, projectRoot, projectConfiguration) {
             }
         }
     }
-    writeJson(tree, packageJsonPath, packageJson);
+    (0, devkit_exports_1.writeJson)(tree, packageJsonPath, packageJson);
 }
 function getInferredTargetCommands(project) {
     const targetCommands = [];

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

@@ -1,2 +1,2 @@
-import type { CreateNodesContext } from 'nx/src/devkit-exports';
+import { 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

@@ -1,16 +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)();
+const devkit_exports_1 = require("nx/src/devkit-exports");
+const devkit_internals_1 = require("nx/src/devkit-internals");
 function calculateHashForCreateNodes(projectRoot, options, context, additionalGlobs = []) {
-    return hashArray([
-        hashWithWorkspaceContext(context.workspaceRoot, [
+    return (0, devkit_exports_1.hashArray)([
+        (0, devkit_internals_1.hashWithWorkspaceContext)(context.workspaceRoot, [
             (0, path_1.join)(projectRoot, '**/*'),
             ...additionalGlobs,
         ]),
-        hashObject(options),
+        (0, devkit_internals_1.hashObject)(options),
     ]);
 }
 exports.calculateHashForCreateNodes = calculateHashForCreateNodes;

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

@@ -2,3 +2,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;
+export declare function clearRequireCache(): void;

package/src/utils/config-utils.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRootTsConfigFileName = exports.getRootTsConfigPath = exports.loadConfigFile = exports.dynamicImport = void 0;
+exports.clearRequireCache = 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 node_url_1 = require("node:url");
-const { workspaceRoot, registerTsProject } = (0, nx_1.requireNx)();
+const devkit_exports_1 = require("nx/src/devkit-exports");
+const devkit_internals_1 = require("nx/src/devkit-internals");
 exports.dynamicImport = new Function('modulePath', 'return import(modulePath);');
 async function loadConfigFile(configFilePath) {
     {
@@ -16,7 +16,7 @@ async function loadConfigFile(configFilePath) {
                 ? (0, path_1.join)((0, path_1.dirname)(configFilePath), 'tsconfig.json')
                 : getRootTsConfigPath();
             if (tsConfigPath) {
-                const unregisterTsProject = registerTsProject(tsConfigPath);
+                const unregisterTsProject = (0, devkit_internals_1.registerTsProject)(tsConfigPath);
                 try {
                     module = await load(configFilePath);
                 }
@@ -37,12 +37,12 @@ async function loadConfigFile(configFilePath) {
 exports.loadConfigFile = loadConfigFile;
 function getRootTsConfigPath() {
     const tsConfigFileName = getRootTsConfigFileName();
-    return tsConfigFileName ? (0, path_1.join)(workspaceRoot, tsConfigFileName) : null;
+    return tsConfigFileName ? (0, path_1.join)(devkit_exports_1.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));
+        const pathExists = (0, fs_1.existsSync)((0, path_1.join)(devkit_exports_1.workspaceRoot, tsConfigName));
         if (pathExists) {
             return tsConfigName;
         }
@@ -50,15 +50,25 @@ function getRootTsConfigFileName() {
     return null;
 }
 exports.getRootTsConfigFileName = getRootTsConfigFileName;
+const packageInstallationDirectories = [
+    `${path_1.sep}node_modules${path_1.sep}`,
+    `${path_1.sep}.yarn${path_1.sep}`,
+];
+function clearRequireCache() {
+    for (const k of Object.keys(require.cache)) {
+        if (!packageInstallationDirectories.some((dir) => k.includes(dir))) {
+            delete require.cache[k];
+        }
+    }
+}
+exports.clearRequireCache = clearRequireCache;
 /**
  * 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];
-        }
+        clearRequireCache();
     }
     try {
         // Try using `require` first, which works for CJS modules.

package/src/utils/convert-nx-executor.d.ts

@@ -1,4 +1,4 @@
-import type { Executor } from 'nx/src/config/misc-interfaces';
+import type { Executor } from 'nx/src/devkit-exports';
 /**
  * Convert an Nx Executor into an Angular Devkit Builder
  *

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

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertNxExecutor = void 0;
-const nx_1 = require("../../nx");
-const { Workspaces, readNxJsonFromDisk, retrieveProjectConfigurationsWithAngularProjects, } = (0, nx_1.requireNx)();
+const package_json_1 = require("./package-json");
+const semver_1 = require("semver");
+const devkit_internals_1 = require("nx/src/devkit-internals");
 /**
  * Convert an Nx Executor into an Angular Devkit Builder
  *
@@ -11,21 +12,25 @@ const { Workspaces, readNxJsonFromDisk, retrieveProjectConfigurationsWithAngular
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 function convertNxExecutor(executor) {
     const builderFunction = (options, builderContext) => {
-        const workspaces = new Workspaces(builderContext.workspaceRoot);
-        const nxJsonConfiguration = readNxJsonFromDisk
-            ? readNxJsonFromDisk(builderContext.workspaceRoot)
-            : // TODO(v19): remove readNxJson. This is to be backwards compatible with Nx 16.5 and below.
-                workspaces.readNxJson();
+        const nxJsonConfiguration = (0, devkit_internals_1.readNxJsonFromDisk)(builderContext.workspaceRoot);
         const promise = async () => {
-            const projectsConfigurations = retrieveProjectConfigurationsWithAngularProjects
-                ? {
-                    version: 2,
-                    projects: await retrieveProjectConfigurationsWithAngularProjects(builderContext.workspaceRoot, nxJsonConfiguration).then((p) => p.projectNodes ?? p.projects),
-                }
-                : // TODO(v19): remove retrieveProjectConfigurations. This is to be backwards compatible with Nx 16.5 and below.
-                    workspaces.readProjectsConfigurations({
-                        _includeProjectsFromAngularJson: true,
-                    });
+            const projectsConfigurations = {
+                version: 2,
+                projects: await (0, devkit_internals_1.retrieveProjectConfigurationsWithAngularProjects)(builderContext.workspaceRoot, nxJsonConfiguration).then((p) => {
+                    if (p.projectNodes) {
+                        return p.projectNodes;
+                    }
+                    // v18.3.4 changed projects to be keyed by root
+                    // rather than project name
+                    if ((0, semver_1.lt)(package_json_1.NX_VERSION, '18.3.4')) {
+                        return p.projects;
+                    }
+                    if (devkit_internals_1.readProjectConfigurationsFromRootMap) {
+                        return (0, devkit_internals_1.readProjectConfigurationsFromRootMap)(p.projects);
+                    }
+                    throw new Error('Unable to successfully map Nx executor -> Angular Builder');
+                }),
+            };
             const context = {
                 root: builderContext.workspaceRoot,
                 projectName: builderContext.target.project,