nx 18.3.0-beta.0 → 18.3.0-beta.1

package/src/project-graph/utils/retrieve-workspace-files.js

@@ -2,15 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configurationGlobs = exports.retrieveProjectConfigurationsWithoutPluginInference = exports.retrieveProjectConfigurationPaths = exports.retrieveProjectConfigurationsWithAngularProjects = exports.retrieveProjectConfigurations = exports.retrieveWorkspaceFiles = void 0;
 const perf_hooks_1 = require("perf_hooks");
-const installation_directory_1 = require("../../utils/installation-directory");
 const angular_json_1 = require("../../adapter/angular-json");
 const nx_json_1 = require("../../config/nx-json");
-const package_json_workspaces_1 = require("../../plugins/package-json-workspaces");
 const project_configuration_utils_1 = require("./project-configuration-utils");
-const nx_plugin_1 = require("../../utils/nx-plugin");
-const project_json_1 = require("../../plugins/project-json/build-nodes/project-json");
+const internal_api_1 = require("../plugins/internal-api");
 const workspace_context_1 = require("../../utils/workspace-context");
 const build_all_workspace_files_1 = require("./build-all-workspace-files");
+const path_1 = require("path");
 /**
  * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
  * @throws
@@ -37,22 +35,23 @@ async function retrieveWorkspaceFiles(workspaceRoot, projectRootMap) {
 exports.retrieveWorkspaceFiles = retrieveWorkspaceFiles;
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.
- *
- * @param workspaceRoot
- * @param nxJson
  */
-async function retrieveProjectConfigurations(workspaceRoot, nxJson) {
-    const plugins = await (0, nx_plugin_1.loadNxPlugins)(nxJson?.plugins ?? [], (0, installation_directory_1.getNxRequirePaths)(workspaceRoot), workspaceRoot);
-    return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins);
+async function retrieveProjectConfigurations(plugins, workspaceRoot, nxJson) {
+    const projects = await _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins);
+    return projects;
 }
 exports.retrieveProjectConfigurations = retrieveProjectConfigurations;
 async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, nxJson) {
-    const plugins = await (0, nx_plugin_1.loadNxPlugins)(nxJson?.plugins ?? [], (0, installation_directory_1.getNxRequirePaths)(workspaceRoot), workspaceRoot);
+    const pluginsToLoad = nxJson?.plugins ?? [];
     if ((0, angular_json_1.shouldMergeAngularProjects)(workspaceRoot, true) &&
-        !plugins.some((p) => p.plugin.name === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME)) {
-        plugins.push({ plugin: angular_json_1.NxAngularJsonPlugin });
+        !pluginsToLoad.some((p) => p === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME ||
+            (typeof p === 'object' && p.plugin === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME))) {
+        pluginsToLoad.push((0, path_1.join)(__dirname, '../../adapter/angular-json'));
     }
-    return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins);
+    const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)(nxJson?.plugins ?? [], workspaceRoot);
+    const res = _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins);
+    cleanup();
+    return res;
 }
 exports.retrieveProjectConfigurationsWithAngularProjects = retrieveProjectConfigurationsWithAngularProjects;
 function _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins) {
@@ -69,25 +68,23 @@ const projectsWithoutPluginCache = new Map();
 // TODO: This function is called way too often, it should be optimized without this cache
 async function retrieveProjectConfigurationsWithoutPluginInference(root) {
     const nxJson = (0, nx_json_1.readNxJson)(root);
-    const plugins = await (0, nx_plugin_1.getDefaultPlugins)(root);
+    const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)([]); // only load default plugins
     const projectGlobPatterns = retrieveProjectConfigurationPaths(root, plugins);
     const cacheKey = root + ',' + projectGlobPatterns.join(',');
     if (projectsWithoutPluginCache.has(cacheKey)) {
         return projectsWithoutPluginCache.get(cacheKey);
     }
     const projectFiles = (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns) ?? [];
-    const { projects } = await (0, project_configuration_utils_1.createProjectConfigurations)(root, nxJson, projectFiles, [
-        { plugin: (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root) },
-        { plugin: project_json_1.ProjectJsonProjectsPlugin },
-    ]);
+    const { projects } = await (0, project_configuration_utils_1.createProjectConfigurations)(root, nxJson, projectFiles, plugins);
     projectsWithoutPluginCache.set(cacheKey, projects);
+    cleanup();
     return projects;
 }
 exports.retrieveProjectConfigurationsWithoutPluginInference = retrieveProjectConfigurationsWithoutPluginInference;
 function configurationGlobs(plugins) {
     const globPatterns = [];
-    for (const { plugin } of plugins) {
-        if (plugin.createNodes) {
+    for (const plugin of plugins) {
+        if ('createNodes' in plugin && plugin.createNodes) {
             globPatterns.push(plugin.createNodes[0]);
         }
     }

package/src/tasks-runner/cache.js

@@ -197,7 +197,7 @@ class Cache {
                     `The local cache artifact in "${td}" was not generated on this machine.`,
                     `As a result, the cache's content integrity cannot be confirmed, which may make cache restoration potentially unsafe.`,
                     `If your machine ID has changed since the artifact was cached, run "nx reset" to fix this issue.`,
-                    `Read about the error and how to address it here: https://nx.dev/recipes/troubleshooting/unknown-local-cache`,
+                    `Read about the error and how to address it here: https://nx.dev/troubleshooting/unknown-local-cache`,
                     ``,
                 ].join('\n');
                 throw new Error(error);

package/src/utils/logger.d.ts

@@ -7,5 +7,6 @@ export declare const logger: {
     log: (...s: any[]) => void;
     debug: (...s: any[]) => void;
     fatal: (...s: any[]) => void;
+    verbose: (...s: any[]) => void;
 };
 export declare function stripIndent(str: string): string;

package/src/utils/logger.js

@@ -34,6 +34,11 @@ exports.logger = {
     fatal: (...s) => {
         console.error(...s);
     },
+    verbose: (...s) => {
+        if (process.env.NX_VERBOSE_LOGGING) {
+            console.log(...s);
+        }
+    },
 };
 function stripIndent(str) {
     const match = str.match(/^[ \t]*(?=\S)/gm);

package/src/utils/nx-plugin.deprecated.d.ts

@@ -1,6 +1,6 @@
 import { ProjectGraphProcessor } from '../config/project-graph';
 import { TargetConfiguration } from '../config/workspace-json-project-json';
-import { LoadedNxPlugin } from './nx-plugin';
+import { NxPluginV2 } from '../project-graph/plugins';
 /**
  * @deprecated Add targets to the projects in a {@link CreateNodes} function instead. This will be removed in Nx 19
  */
@@ -28,4 +28,4 @@ export type NxPluginV1 = {
 /**
  * @todo(@agentender) v19: Remove this fn when we remove readWorkspaceConfig
  */
-export declare function getDefaultPluginsSync(root: string): LoadedNxPlugin[];
+export declare function getDefaultPluginsSync(root: string): NxPluginV2[];

package/src/utils/nx-plugin.deprecated.js

@@ -4,7 +4,7 @@ exports.getDefaultPluginsSync = void 0;
 const angular_json_1 = require("../adapter/angular-json");
 const project_json_1 = require("../plugins/project-json/build-nodes/project-json");
 const target_defaults_plugin_1 = require("../plugins/target-defaults/target-defaults-plugin");
-const package_json_workspaces_1 = require("../plugins/package-json-workspaces");
+const PackageJsonWorkspacesPlugin = require("../plugins/package-json-workspaces");
 /**
  * @todo(@agentender) v19: Remove this fn when we remove readWorkspaceConfig
  */
@@ -14,12 +14,10 @@ function getDefaultPluginsSync(root) {
         ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
             ? [require('../adapter/angular-json').NxAngularJsonPlugin]
             : []),
-        target_defaults_plugin_1.TargetDefaultsPlugin,
-        (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root),
-        project_json_1.ProjectJsonProjectsPlugin,
+        target_defaults_plugin_1.default,
+        PackageJsonWorkspacesPlugin,
+        project_json_1.default,
     ];
-    return plugins.map((p) => ({
-        plugin: p,
-    }));
+    return plugins;
 }
 exports.getDefaultPluginsSync = getDefaultPluginsSync;

package/src/utils/plugins/plugin-capabilities.d.ts

@@ -1,4 +1,4 @@
-import type { PluginCapabilities } from './models';
 import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import type { PluginCapabilities } from './models';
 export declare function getPluginCapabilities(workspaceRoot: string, pluginName: string, projects: Record<string, ProjectConfiguration>, includeRuntimeCapabilities?: boolean): Promise<PluginCapabilities | null>;
 export declare function listPluginCapabilities(pluginName: string, projects: Record<string, ProjectConfiguration>): Promise<void>;

package/src/utils/plugins/plugin-capabilities.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listPluginCapabilities = exports.getPluginCapabilities = void 0;
-const workspace_root_1 = require("../workspace-root");
 const chalk = require("chalk");
 const path_1 = require("path");
-const output_1 = require("../output");
-const shared_1 = require("./shared");
+const plugins_1 = require("../../project-graph/plugins");
+const loader_1 = require("../../project-graph/plugins/loader");
 const fileutils_1 = require("../fileutils");
-const package_manager_1 = require("../package-manager");
-const nx_plugin_1 = require("../nx-plugin");
 const installation_directory_1 = require("../installation-directory");
+const output_1 = require("../output");
+const package_manager_1 = require("../package-manager");
+const workspace_root_1 = require("../workspace-root");
+const shared_1 = require("./shared");
 function tryGetCollection(packageJsonPath, collectionFile, propName) {
     if (!collectionFile) {
         return null;
@@ -24,9 +25,9 @@ function tryGetCollection(packageJsonPath, collectionFile, propName) {
 }
 async function getPluginCapabilities(workspaceRoot, pluginName, projects, includeRuntimeCapabilities = false) {
     try {
-        const { json: packageJson, path: packageJsonPath } = await (0, nx_plugin_1.readPluginPackageJson)(pluginName, projects, (0, installation_directory_1.getNxRequirePaths)(workspaceRoot));
+        const { json: packageJson, path: packageJsonPath } = await (0, plugins_1.readPluginPackageJson)(pluginName, projects, (0, installation_directory_1.getNxRequirePaths)(workspaceRoot));
         const pluginModule = includeRuntimeCapabilities
-            ? await tryGetModule(packageJson, workspaceRoot, projects)
+            ? await tryGetModule(packageJson, workspaceRoot)
             : {};
         return {
             name: pluginName,
@@ -56,17 +57,22 @@ async function getPluginCapabilities(workspaceRoot, pluginName, projects, includ
     }
 }
 exports.getPluginCapabilities = getPluginCapabilities;
-async function tryGetModule(packageJson, workspaceRoot, projects) {
+async function tryGetModule(packageJson, workspaceRoot) {
     try {
-        return (packageJson.generators ??
+        if (packageJson.generators ??
             packageJson.executors ??
             packageJson['nx-migrations'] ??
             packageJson['schematics'] ??
-            packageJson['builders'])
-            ? (await (0, nx_plugin_1.loadNxPluginAsync)(packageJson.name, (0, installation_directory_1.getNxRequirePaths)(workspaceRoot), projects, workspaceRoot)).plugin
-            : {
+            packageJson['builders']) {
+            const [pluginPromise] = (0, loader_1.loadNxPlugin)(packageJson.name, workspaceRoot);
+            const plugin = await pluginPromise;
+            return plugin;
+        }
+        else {
+            return {
                 name: packageJson.name,
             };
+        }
     }
     catch {
         return null;

package/src/utils/nx-plugin.js

@@ -1,309 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefaultPlugins = exports.unregisterPluginTSTranspiler = exports.registerPluginTSTranspiler = exports.resolveLocalNxPlugin = exports.readPluginPackageJson = exports.isNxPluginV1 = exports.isNxPluginV2 = exports.ensurePluginIsV2 = exports.loadNxPlugins = exports.loadNxPluginAsync = exports.getPluginPathAndName = exports.nxPluginCache = void 0;
-const tslib_1 = require("tslib");
-const fs_1 = require("fs");
-const path = require("path");
-const workspaces_1 = require("../config/workspaces");
-const workspace_root_1 = require("./workspace-root");
-const fileutils_1 = require("../utils/fileutils");
-const package_json_1 = require("./package-json");
-const register_1 = require("../plugins/js/utils/register");
-const logger_1 = require("./logger");
-const find_project_for_path_1 = require("../project-graph/utils/find-project-for-path");
-const path_1 = require("./path");
-const path_2 = require("path");
-const installation_directory_1 = require("./installation-directory");
-const typescript_1 = require("../plugins/js/utils/typescript");
-const nx_json_1 = require("../config/nx-json");
-const globs_1 = require("./globs");
-const angular_json_1 = require("../adapter/angular-json");
-const package_json_workspaces_1 = require("../plugins/package-json-workspaces");
-const project_json_1 = require("../plugins/project-json/build-nodes/project-json");
-const package_json_next_to_project_json_1 = require("../plugins/project-json/build-nodes/package-json-next-to-project-json");
-const retrieve_workspace_files_1 = require("../project-graph/utils/retrieve-workspace-files");
-const target_defaults_plugin_1 = require("../plugins/target-defaults/target-defaults-plugin");
-tslib_1.__exportStar(require("./nx-plugin.deprecated"), exports);
-// Short lived cache (cleared between cmd runs)
-// holding resolved nx plugin objects.
-// Allows loadNxPlugins to be called multiple times w/o
-// executing resolution mulitple times.
-exports.nxPluginCache = new Map();
-function getPluginPathAndName(moduleName, paths, projects, root) {
-    let pluginPath;
-    try {
-        pluginPath = require.resolve(moduleName, {
-            paths,
-        });
-    }
-    catch (e) {
-        if (e.code === 'MODULE_NOT_FOUND') {
-            const plugin = resolveLocalNxPlugin(moduleName, (0, nx_json_1.readNxJson)(root), projects, root);
-            if (plugin) {
-                const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
-                pluginPath = main ? path.join(root, main) : plugin.path;
-            }
-            else {
-                logger_1.logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
-                throw e;
-            }
-        }
-        else {
-            throw e;
-        }
-    }
-    const packageJsonPath = path.join(pluginPath, 'package.json');
-    const extension = path.extname(pluginPath);
-    // Register the ts-transpiler if we are pointing to a
-    // plain ts file that's not part of a plugin project
-    if (extension === '.ts' && !tsNodeAndPathsUnregisterCallback) {
-        registerPluginTSTranspiler();
-    }
-    const { name } = !['.ts', '.js'].some((x) => x === extension) && // Not trying to point to a ts or js file
-        (0, fs_1.existsSync)(packageJsonPath) // plugin has a package.json
-        ? (0, fileutils_1.readJsonFile)(packageJsonPath) // read name from package.json
-        : { name: moduleName };
-    return { pluginPath, name };
-}
-exports.getPluginPathAndName = getPluginPathAndName;
-async function loadNxPluginAsync(pluginConfiguration, paths, projects, root) {
-    const { plugin: moduleName, options } = typeof pluginConfiguration === 'object'
-        ? pluginConfiguration
-        : { plugin: pluginConfiguration, options: undefined };
-    let pluginModule = exports.nxPluginCache.get(moduleName);
-    const include = typeof pluginConfiguration === 'object'
-        ? pluginConfiguration.include
-        : undefined;
-    const exclude = typeof pluginConfiguration === 'object'
-        ? pluginConfiguration.exclude
-        : undefined;
-    if (pluginModule) {
-        return {
-            plugin: pluginModule,
-            options,
-            include,
-            exclude,
-        };
-    }
-    performance.mark(`Load Nx Plugin: ${moduleName} - start`);
-    let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projects, root);
-    const plugin = ensurePluginIsV2((await Promise.resolve(`${pluginPath}`).then(s => require(s))));
-    plugin.name ??= name;
-    exports.nxPluginCache.set(moduleName, plugin);
-    performance.mark(`Load Nx Plugin: ${moduleName} - end`);
-    performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);
-    return {
-        plugin,
-        options,
-        include,
-        exclude,
-    };
-}
-exports.loadNxPluginAsync = loadNxPluginAsync;
-async function loadNxPlugins(plugins, paths = (0, installation_directory_1.getNxRequirePaths)(), root = workspace_root_1.workspaceRoot, projects) {
-    const result = [
-        { plugin: package_json_next_to_project_json_1.PackageJsonProjectsNextToProjectJsonPlugin },
-    ];
-    plugins ??= [];
-    // When loading plugins for `createNodes`, we don't know what projects exist yet.
-    // Try resolving plugins
-    for (const plugin of plugins) {
-        try {
-            require.resolve(typeof plugin === 'string' ? plugin : plugin.plugin);
-        }
-        catch {
-            // If a plugin cannot be resolved, we will need projects to resolve it
-            projects ??= await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
-            break;
-        }
-    }
-    for (const plugin of plugins) {
-        result.push(await loadNxPluginAsync(plugin, paths, projects, root));
-    }
-    // We push the nx core node plugins onto the end, s.t. it overwrites any other plugins
-    result.push(...(await getDefaultPlugins(root)));
-    return result;
-}
-exports.loadNxPlugins = loadNxPlugins;
-function ensurePluginIsV2(plugin) {
-    if (isNxPluginV2(plugin)) {
-        return plugin;
-    }
-    if (isNxPluginV1(plugin) && plugin.projectFilePatterns) {
-        return {
-            ...plugin,
-            createNodes: [
-                `*/**/${(0, globs_1.combineGlobPatterns)(plugin.projectFilePatterns)}`,
-                (configFilePath) => {
-                    const root = (0, path_2.dirname)(configFilePath);
-                    return {
-                        projects: {
-                            [root]: {
-                                name: (0, workspaces_1.toProjectName)(configFilePath),
-                                root,
-                                targets: plugin.registerProjectTargets?.(configFilePath),
-                            },
-                        },
-                    };
-                },
-            ],
-        };
-    }
-    return plugin;
-}
-exports.ensurePluginIsV2 = ensurePluginIsV2;
-function isNxPluginV2(plugin) {
-    return 'createNodes' in plugin || 'createDependencies' in plugin;
-}
-exports.isNxPluginV2 = isNxPluginV2;
-function isNxPluginV1(plugin) {
-    return 'processProjectGraph' in plugin || 'projectFilePatterns' in plugin;
-}
-exports.isNxPluginV1 = isNxPluginV1;
-function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
-    try {
-        const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
-        return {
-            json: result.packageJson,
-            path: result.path,
-        };
-    }
-    catch (e) {
-        if (e.code === 'MODULE_NOT_FOUND') {
-            const nxJson = (0, nx_json_1.readNxJson)();
-            const localPluginPath = resolveLocalNxPlugin(pluginName, nxJson, projects);
-            if (localPluginPath) {
-                const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
-                return {
-                    path: localPluginPackageJson,
-                    json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
-                };
-            }
-        }
-        throw e;
-    }
-}
-exports.readPluginPackageJson = readPluginPackageJson;
-/**
- * Builds a plugin package and returns the path to output
- * @param importPath What is the import path that refers to a potential plugin?
- * @returns The path to the built plugin, or null if it doesn't exist
- */
-const localPluginCache = {};
-function resolveLocalNxPlugin(importPath, nxJsonConfiguration, projects, root = workspace_root_1.workspaceRoot) {
-    localPluginCache[importPath] ??= lookupLocalPlugin(importPath, nxJsonConfiguration, projects, root);
-    return localPluginCache[importPath];
-}
-exports.resolveLocalNxPlugin = resolveLocalNxPlugin;
-let tsNodeAndPathsUnregisterCallback = undefined;
-/**
- * Register swc-node or ts-node if they are not currently registered
- * with some default settings which work well for Nx plugins.
- */
-function registerPluginTSTranspiler() {
-    if (!tsNodeAndPathsUnregisterCallback) {
-        // nx-ignore-next-line
-        const ts = require('typescript');
-        // Get the first tsconfig that matches the allowed set
-        const tsConfigName = [
-            (0, path_2.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json'),
-            (0, path_2.join)(workspace_root_1.workspaceRoot, 'tsconfig.json'),
-        ].find((x) => (0, fs_1.existsSync)(x));
-        const tsConfig = tsConfigName
-            ? (0, typescript_1.readTsConfig)(tsConfigName)
-            : {};
-        const unregisterTsConfigPaths = (0, register_1.registerTsConfigPaths)(tsConfigName);
-        const unregisterTranspiler = (0, register_1.registerTranspiler)({
-            experimentalDecorators: true,
-            emitDecoratorMetadata: true,
-            ...tsConfig.options,
-        });
-        tsNodeAndPathsUnregisterCallback = () => {
-            unregisterTsConfigPaths();
-            unregisterTranspiler();
-        };
-    }
-}
-exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
-/**
- * Unregister the ts-node transpiler if it is registered
- */
-function unregisterPluginTSTranspiler() {
-    if (tsNodeAndPathsUnregisterCallback) {
-        tsNodeAndPathsUnregisterCallback();
-        tsNodeAndPathsUnregisterCallback = undefined;
-    }
-}
-exports.unregisterPluginTSTranspiler = unregisterPluginTSTranspiler;
-function lookupLocalPlugin(importPath, nxJsonConfiguration, projects, root = workspace_root_1.workspaceRoot) {
-    const plugin = findNxProjectForImportPath(importPath, projects, root);
-    if (!plugin) {
-        return null;
-    }
-    if (!tsNodeAndPathsUnregisterCallback) {
-        registerPluginTSTranspiler();
-    }
-    const projectConfig = projects[plugin];
-    return { path: path.join(root, projectConfig.root), projectConfig };
-}
-function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    const tsConfigPaths = readTsConfigPaths(root);
-    const possiblePaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p))));
-    if (possiblePaths?.length) {
-        const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projects);
-        for (const tsConfigPath of possiblePaths) {
-            const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
-            if (nxProject) {
-                return nxProject;
-            }
-        }
-        if (process.env.NX_VERBOSE_LOGGING) {
-            console.log('Unable to find local plugin', possiblePaths, projectRootMappings);
-        }
-        throw new Error('Unable to resolve local plugin with import path ' + importPath);
-    }
-}
-let tsconfigPaths;
-function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {
-    if (!tsconfigPaths) {
-        const tsconfigPath = ['tsconfig.base.json', 'tsconfig.json']
-            .map((x) => path.join(root, x))
-            .filter((x) => (0, fs_1.existsSync)(x))[0];
-        if (!tsconfigPath) {
-            throw new Error('unable to find tsconfig.base.json or tsconfig.json');
-        }
-        const { compilerOptions } = (0, fileutils_1.readJsonFile)(tsconfigPath);
-        tsconfigPaths = compilerOptions?.paths;
-    }
-    return tsconfigPaths ?? {};
-}
-function readPluginMainFromProjectConfiguration(plugin) {
-    const { main } = Object.values(plugin.targets).find((x) => [
-        '@nx/js:tsc',
-        '@nrwl/js:tsc',
-        '@nx/js:swc',
-        '@nrwl/js:swc',
-        '@nx/node:package',
-        '@nrwl/node:package',
-    ].includes(x.executor))?.options ||
-        plugin.targets?.build?.options ||
-        {};
-    return main;
-}
-async function getDefaultPlugins(root) {
-    const plugins = [
-        await Promise.resolve().then(() => require('../plugins/js')),
-        target_defaults_plugin_1.TargetDefaultsPlugin,
-        ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
-            ? [
-                await Promise.resolve().then(() => require('../adapter/angular-json')).then((m) => m.NxAngularJsonPlugin),
-            ]
-            : []),
-        (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root),
-        project_json_1.ProjectJsonProjectsPlugin,
-    ];
-    return plugins.map((p) => ({
-        plugin: p,
-    }));
-}
-exports.getDefaultPlugins = getDefaultPlugins;