@nx/devkit 0.0.0-pr-22179-271588f → 0.0.0-pr-26482-ebe2dba

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

@@ -0,0 +1,13 @@
+import { CreateNodes, CreateNodesV2, 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
+
+ */
+export declare function addPlugin<PluginOptions>(tree: Tree, graph: ProjectGraph, pluginName: string, createNodesTuple: CreateNodesV2<PluginOptions>, options: Partial<Record<keyof PluginOptions, PluginOptions[keyof PluginOptions][]>>, shouldUpdatePackageJsonScripts: boolean): Promise<void>;
+/**
+ * @deprecated Use `addPlugin` instead
+ * Iterates through various forms of plugin options to find the one which does not conflict with the current graph
+
+ */
+export declare function addPluginV1<PluginOptions>(tree: Tree, graph: ProjectGraph, pluginName: string, createNodesTuple: CreateNodes<PluginOptions>, options: Partial<Record<keyof PluginOptions, PluginOptions[keyof PluginOptions][]>>, shouldUpdatePackageJsonScripts: boolean): Promise<void>;
+export declare function generateCombinations<T>(input: Record<string, T[]>): Record<string, T>[];

package/src/utils/add-plugin.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCombinations = exports.addPluginV1 = exports.addPlugin = void 0;
+const yargs = require("yargs-parser");
+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) {
+    return _addPluginInternal(tree, graph, pluginName, (pluginOptions) => new devkit_internals_1.LoadedNxPlugin({
+        name: pluginName,
+        createNodesV2: createNodesTuple,
+    }, {
+        plugin: pluginName,
+        options: pluginOptions,
+    }), options, shouldUpdatePackageJsonScripts);
+}
+exports.addPlugin = addPlugin;
+/**
+ * @deprecated Use `addPlugin` instead
+ * Iterates through various forms of plugin options to find the one which does not conflict with the current graph
+
+ */
+async function addPluginV1(tree, graph, pluginName, createNodesTuple, options, shouldUpdatePackageJsonScripts) {
+    return _addPluginInternal(tree, graph, pluginName, (pluginOptions) => new devkit_internals_1.LoadedNxPlugin({
+        name: pluginName,
+        createNodes: createNodesTuple,
+    }, {
+        plugin: pluginName,
+        options: pluginOptions,
+    }), options, shouldUpdatePackageJsonScripts);
+}
+exports.addPluginV1 = addPluginV1;
+async function _addPluginInternal(tree, graph, pluginName, pluginFactory, options, shouldUpdatePackageJsonScripts) {
+    const graphNodes = Object.values(graph.nodes);
+    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 && !p.include)) {
+            // Plugin has already been added
+            return;
+        }
+        global.NX_GRAPH_CREATION = true;
+        try {
+            projConfigs = await (0, devkit_internals_1.retrieveProjectConfigurations)([pluginFactory(pluginOptions)], tree.root, nxJson);
+        }
+        catch (e) {
+            // Errors are okay for this because we're only running 1 plugin
+            if (e instanceof devkit_internals_1.ProjectConfigurationsError) {
+                projConfigs = e.partialProjectConfigurationsResult;
+            }
+            else {
+                throw e;
+            }
+        }
+        global.NX_GRAPH_CREATION = false;
+        for (const projConfig of Object.values(projConfigs.projects)) {
+            const node = graphNodes.find((node) => node.data.root === projConfig.root);
+            if (!node) {
+                continue;
+            }
+            for (const targetName in projConfig.targets) {
+                if (node.data.targets[targetName]) {
+                    // Conflicting Target Name, check the next one
+                    pluginOptions = null;
+                    continue optionsLoop;
+                }
+            }
+        }
+        break;
+    }
+    if (!pluginOptions) {
+        throw new Error('Could not add the plugin in a way which does not conflict with existing targets. Please report this error at: https://github.com/nrwl/nx/issues/new/choose');
+    }
+    nxJson.plugins.push({
+        plugin: pluginName,
+        options: pluginOptions,
+    });
+    (0, devkit_exports_1.updateNxJson)(tree, nxJson);
+    if (shouldUpdatePackageJsonScripts) {
+        updatePackageScripts(tree, projConfigs);
+    }
+}
+function updatePackageScripts(tree, projectConfigurations) {
+    for (const projectConfig of Object.values(projectConfigurations.projects)) {
+        const projectRoot = projectConfig.root;
+        processProject(tree, projectRoot, projectConfig);
+    }
+}
+function processProject(tree, projectRoot, projectConfiguration) {
+    const packageJsonPath = `${projectRoot}/package.json`;
+    if (!tree.exists(packageJsonPath)) {
+        return;
+    }
+    const packageJson = (0, devkit_exports_1.readJson)(tree, packageJsonPath);
+    if (!packageJson.scripts || !Object.keys(packageJson.scripts).length) {
+        return;
+    }
+    const targetCommands = getInferredTargetCommands(projectConfiguration);
+    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);
+                    }
+                }
+            }
+        }
+    }
+    (0, devkit_exports_1.writeJson)(tree, packageJsonPath, packageJson);
+}
+function getInferredTargetCommands(project) {
+    const targetCommands = [];
+    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 generateCombinations(input) {
+    // This is reversed so that combinations have the first defined property updated first
+    const keys = Object.keys(input).reverse();
+    return _generateCombinations(Object.values(input).reverse()).map((combination) => {
+        const result = {};
+        combination.reverse().forEach((combo, i) => {
+            result[keys[keys.length - i - 1]] = combo;
+        });
+        return result;
+    });
+}
+exports.generateCombinations = generateCombinations;
+/**
+ * Generate all possible combinations of a 2-dimensional array.
+ *
+ * Useful for generating all possible combinations of options for a plugin
+ */
+function _generateCombinations(input) {
+    if (input.length === 0) {
+        return [[]];
+    }
+    else {
+        const [first, ...rest] = input;
+        const partialCombinations = _generateCombinations(rest);
+        return first.flatMap((value) => partialCombinations.map((combination) => [value, ...combination]));
+    }
+}

package/src/utils/async-iterable/combine-async-iterables.js

@@ -24,8 +24,8 @@ async function* combineAsyncIterables(..._iterators) {
         iterators.shift();
     }
     const getNextAsyncIteratorValue = getNextAsyncIteratorFactory(options);
+    const asyncIteratorsValues = new Map(iterators.map((it, idx) => [idx, getNextAsyncIteratorValue(it, idx)]));
     try {
-        const asyncIteratorsValues = new Map(iterators.map((it, idx) => [idx, getNextAsyncIteratorValue(it, idx)]));
         do {
             const { iterator, index } = await Promise.race(asyncIteratorsValues.values());
             if (iterator.done) {
@@ -38,7 +38,9 @@ async function* combineAsyncIterables(..._iterators) {
         } while (asyncIteratorsValues.size > 0);
     }
     finally {
-        await Promise.allSettled(iterators.map((it) => it['return']?.()));
+        for (const [index, iterator] of asyncIteratorsValues.entries())
+            if (iterator?.['return'] !== null)
+                iterator['return']?.();
     }
 }
 exports.combineAsyncIterables = combineAsyncIterables;

package/src/utils/binary-extensions.js

@@ -15,6 +15,7 @@ const binaryExtensions = new Set([
     '.ai',
     '.aif',
     '.aiff',
+    '.als',
     '.alz',
     '.ape',
     '.apk',
@@ -139,6 +140,7 @@ const binaryExtensions = new Set([
     '.mxu',
     '.nef',
     '.npx',
+    '.npy',
     '.numbers',
     '.nupkg',
     '.o',
@@ -159,6 +161,8 @@ const binaryExtensions = new Set([
     '.pea',
     '.pgm',
     '.pic',
+    '.pkg',
+    '.plist',
     '.png',
     '.pnm',
     '.pot',

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

@@ -1,2 +1,2 @@
-import type { CreateNodesContext } from 'nx/src/devkit-exports';
-export declare function calculateHashForCreateNodes(projectRoot: string, options: object, context: CreateNodesContext, additionalGlobs?: string[]): string;
+import { CreateNodesContext } from 'nx/src/devkit-exports';
+export declare function calculateHashForCreateNodes(projectRoot: string, options: object, context: CreateNodesContext, additionalGlobs?: string[]): Promise<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)();
-function calculateHashForCreateNodes(projectRoot, options, context, additionalGlobs = []) {
-    return hashArray([
-        hashWithWorkspaceContext(context.workspaceRoot, [
+const devkit_exports_1 = require("nx/src/devkit-exports");
+const devkit_internals_1 = require("nx/src/devkit-internals");
+async function calculateHashForCreateNodes(projectRoot, options, context, additionalGlobs = []) {
+    return (0, devkit_exports_1.hashArray)([
+        await (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,10 +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 { workspaceRoot, registerTsProject } = (0, nx_1.requireNx)();
+const node_url_1 = require("node:url");
+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) {
     {
@@ -15,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);
                 }
@@ -36,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;
         }
@@ -49,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.
@@ -66,8 +77,9 @@ async function load(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()}`);
+            // If `require` fails to load ESM, try dynamic `import()`. ESM requires file url protocol for handling absolute paths.
+            const pathAsFileUrl = (0, node_url_1.pathToFileURL)(path).pathname;
+            return await (0, exports.dynamicImport)(`${pathAsFileUrl}?t=${Date.now()}`);
         }
         // Re-throw all other errors
         throw e;

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, shutdownPluginWorkers, } = (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,22 +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,
-                    });
-            shutdownPluginWorkers?.();
+            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,

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

@@ -1,5 +1,5 @@
-import type { CreateNodesContext } from 'nx/src/devkit-exports';
 import type { InputDefinition } from 'nx/src/config/workspace-json-project-json';
+import { CreateNodesContext } from 'nx/src/devkit-exports';
 /**
  * Get the named inputs available for a directory
  */

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

@@ -3,19 +3,18 @@ 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)();
+const devkit_exports_1 = require("nx/src/devkit-exports");
 /**
  * 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)
+        ? (0, devkit_exports_1.readJsonFile)(projectJsonPath)
         : null;
     const packageJsonPath = (0, path_1.join)(directory, 'package.json');
     const packageJson = (0, fs_1.existsSync)(packageJsonPath)
-        ? readJsonFile(packageJsonPath)
+        ? (0, devkit_exports_1.readJsonFile)(packageJsonPath)
         : null;
     return {
         ...context.nxJsonConfiguration.namedInputs,

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

@@ -1,4 +1,4 @@
-import type { Tree } from 'nx/src/generators/tree';
+import { Tree } from 'nx/src/devkit-exports';
 /**
  * Returns workspace defaults. It includes defaults folders for apps and libs,
  * and the default scope.