nx 18.1.0-canary.20240309-235ca8c → 18.1.0-canary.20240313-81df848

package/src/tasks-runner/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unparse = exports.isCacheableTask = exports.shouldStreamOutput = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getCliPath = exports.calculateReverseDeps = exports.removeIdsFromGraph = exports.removeTasksFromTaskGraph = exports.getCustomHasher = exports.getExecutorForTask = exports.getExecutorNameForTask = exports.interpolate = exports.getOutputsForTargetAndConfiguration = exports.transformLegacyOutputs = exports.validateOutputs = exports.getOutputs = exports.expandDependencyConfigSyntaxSugar = exports.getDependencyConfigs = exports.getCommandAsString = void 0;
+exports.unparse = exports.isCacheableTask = exports.shouldStreamOutput = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getCliPath = exports.calculateReverseDeps = exports.removeIdsFromGraph = exports.removeTasksFromTaskGraph = exports.getCustomHasher = exports.getExecutorForTask = exports.getExecutorNameForTask = exports.getTargetConfigurationForTask = exports.interpolate = exports.getOutputsForTargetAndConfiguration = exports.transformLegacyOutputs = exports.validateOutputs = exports.getOutputs = exports.expandDependencyConfigSyntaxSugar = exports.getDependencyConfigs = exports.getCommandAsString = void 0;
 const output_1 = require("../utils/output");
 const path_1 = require("path");
 const workspace_root_1 = require("../utils/workspace-root");
@@ -177,19 +177,23 @@ function interpolate(template, data) {
     });
 }
 exports.interpolate = interpolate;
-async function getExecutorNameForTask(task, projectGraph) {
+function getTargetConfigurationForTask(task, projectGraph) {
     const project = projectGraph.nodes[task.target.project].data;
-    return project.targets[task.target.target].executor;
+    return project.targets[task.target.target];
+}
+exports.getTargetConfigurationForTask = getTargetConfigurationForTask;
+function getExecutorNameForTask(task, projectGraph) {
+    return getTargetConfigurationForTask(task, projectGraph)?.executor;
 }
 exports.getExecutorNameForTask = getExecutorNameForTask;
-async function getExecutorForTask(task, projectGraph) {
-    const executor = await getExecutorNameForTask(task, projectGraph);
+function getExecutorForTask(task, projectGraph) {
+    const executor = getExecutorNameForTask(task, projectGraph);
     const [nodeModule, executorName] = executor.split(':');
     return (0, executor_utils_1.getExecutorInformation)(nodeModule, executorName, workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects);
 }
 exports.getExecutorForTask = getExecutorForTask;
-async function getCustomHasher(task, projectGraph) {
-    const factory = (await getExecutorForTask(task, projectGraph)).hasherFactory;
+function getCustomHasher(task, projectGraph) {
+    const factory = getExecutorForTask(task, projectGraph).hasherFactory;
     return factory ? factory() : null;
 }
 exports.getCustomHasher = getCustomHasher;

package/src/utils/logger.d.ts

@@ -7,6 +7,5 @@ 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,11 +34,6 @@ 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/{project-graph/plugins/public-api.d.ts → utils/nx-plugin.d.ts}

@@ -1,8 +1,9 @@
-import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
-import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../../config/project-graph';
-import { ProjectConfiguration } from '../../config/workspace-json-project-json';
-import { NxJsonConfiguration } from '../../config/nx-json';
-import { RawProjectGraphDependency } from '../project-graph-builder';
+import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/project-graph';
+import { PackageJson } from './package-json';
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { NxJsonConfiguration, PluginConfiguration } from '../config/nx-json';
+import { NxPluginV1 } from './nx-plugin.deprecated';
+import { RawProjectGraphDependency } from '../project-graph/project-graph-builder';
 /**
  * Context for {@link CreateNodesFunction}
  */
@@ -15,7 +16,6 @@ export interface CreateNodesContext {
  * Used for creating nodes for the {@link ProjectGraph}
  */
 export type CreateNodesFunction<T = unknown> = (projectConfigurationFile: string, options: T | undefined, context: CreateNodesContext) => CreateNodesResult | Promise<CreateNodesResult>;
-export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export interface CreateNodesResult {
     /**
      * A map of project root -> project configuration
@@ -73,13 +73,47 @@ export type NxPluginV2<TOptions = unknown> = {
      * Provides a file pattern and function that retrieves configuration info from
      * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFile }
      */
-    createNodes?: CreateNodes<TOptions>;
+    createNodes?: CreateNodes;
     /**
      * Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
      */
     createDependencies?: CreateDependencies<TOptions>;
 };
+export * from './nx-plugin.deprecated';
 /**
  * A plugin for Nx
  */
 export type NxPlugin = NxPluginV1 | NxPluginV2;
+export type LoadedNxPlugin = {
+    plugin: NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
+    options?: unknown;
+};
+export declare const nxPluginCache: Map<string, LoadedNxPlugin['plugin']>;
+export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {
+    pluginPath: string;
+    name: any;
+};
+export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): Promise<LoadedNxPlugin>;
+export declare function loadNxPlugins(plugins: PluginConfiguration[], paths?: string[], root?: string, projects?: Record<string, ProjectConfiguration>): Promise<LoadedNxPlugin[]>;
+export declare function ensurePluginIsV2(plugin: NxPlugin): NxPluginV2;
+export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
+export declare function isNxPluginV1(plugin: NxPlugin): plugin is NxPluginV1;
+export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
+    path: string;
+    json: PackageJson;
+};
+export declare function resolveLocalNxPlugin(importPath: string, nxJsonConfiguration: NxJsonConfiguration, projects: Record<string, ProjectConfiguration>, root?: string): {
+    path: string;
+    projectConfig: ProjectConfiguration;
+} | null;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+export declare function registerPluginTSTranspiler(): void;
+/**
+ * Unregister the ts-node transpiler if it is registered
+ */
+export declare function unregisterPluginTSTranspiler(): void;
+export declare function getDefaultPlugins(root: string): Promise<LoadedNxPlugin[]>;
+type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

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

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 PackageJsonWorkspacesPlugin = require("../plugins/package-json-workspaces");
+const package_json_workspaces_1 = require("../plugins/package-json-workspaces");
 /**
  * @todo(@agentender) v19: Remove this fn when we remove readWorkspaceConfig
  */
@@ -14,9 +14,9 @@ function getDefaultPluginsSync(root) {
         ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
             ? [require('../adapter/angular-json').NxAngularJsonPlugin]
             : []),
-        target_defaults_plugin_1.default,
-        PackageJsonWorkspacesPlugin,
-        project_json_1.default,
+        target_defaults_plugin_1.TargetDefaultsPlugin,
+        (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root),
+        project_json_1.ProjectJsonProjectsPlugin,
     ];
     return plugins.map((p) => ({
         plugin: p,

package/src/utils/nx-plugin.js

@@ -0,0 +1,293 @@
+"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);
+    if (pluginModule) {
+        return { plugin: pluginModule, options };
+    }
+    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 };
+}
+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;

package/src/utils/output.js

@@ -181,7 +181,7 @@ class CLIOutput {
     getStatusIcon(taskStatus) {
         switch (taskStatus) {
             case 'success':
-                return '✔️';
+                return '✅';
             case 'failure':
                 return '❌';
             case 'skipped':

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

@@ -1,4 +1,4 @@
-import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import type { PluginCapabilities } from './models';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 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,16 +1,15 @@
 "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 plugins_1 = require("../../project-graph/plugins");
-const internal_api_1 = require("../../project-graph/plugins/internal-api");
-const fileutils_1 = require("../fileutils");
-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");
+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");
 function tryGetCollection(packageJsonPath, collectionFile, propName) {
     if (!collectionFile) {
         return null;
@@ -25,9 +24,9 @@ function tryGetCollection(packageJsonPath, collectionFile, propName) {
 }
 async function getPluginCapabilities(workspaceRoot, pluginName, projects, includeRuntimeCapabilities = false) {
     try {
-        const { json: packageJson, path: packageJsonPath } = await (0, plugins_1.readPluginPackageJson)(pluginName, projects, (0, installation_directory_1.getNxRequirePaths)(workspaceRoot));
+        const { json: packageJson, path: packageJsonPath } = await (0, nx_plugin_1.readPluginPackageJson)(pluginName, projects, (0, installation_directory_1.getNxRequirePaths)(workspaceRoot));
         const pluginModule = includeRuntimeCapabilities
-            ? await tryGetModule(packageJson, workspaceRoot)
+            ? await tryGetModule(packageJson, workspaceRoot, projects)
             : {};
         return {
             name: pluginName,
@@ -57,14 +56,14 @@ async function getPluginCapabilities(workspaceRoot, pluginName, projects, includ
     }
 }
 exports.getPluginCapabilities = getPluginCapabilities;
-async function tryGetModule(packageJson, workspaceRoot) {
+async function tryGetModule(packageJson, workspaceRoot, projects) {
     try {
         return (packageJson.generators ??
             packageJson.executors ??
             packageJson['nx-migrations'] ??
             packageJson['schematics'] ??
             packageJson['builders'])
-            ? (await (0, internal_api_1.loadPlugin)(packageJson.name, workspaceRoot)).plugin
+            ? (await (0, nx_plugin_1.loadNxPluginAsync)(packageJson.name, (0, installation_directory_1.getNxRequirePaths)(workspaceRoot), projects, workspaceRoot)).plugin
             : {
                 name: packageJson.name,
             };

package/src/daemon/server/plugins.d.ts

@@ -1,3 +0,0 @@
-import { RemotePlugin } from '../../project-graph/plugins/internal-api';
-export declare function getPlugins(): Promise<RemotePlugin[]>;
-export declare function cleanupPlugins(): void;

package/src/daemon/server/plugins.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanupPlugins = exports.getPlugins = void 0;
-const nx_json_1 = require("../../config/nx-json");
-const internal_api_1 = require("../../project-graph/plugins/internal-api");
-const workspace_root_1 = require("../../utils/workspace-root");
-let loadedPlugins;
-let cleanup;
-async function getPlugins() {
-    if (loadedPlugins) {
-        return loadedPlugins;
-    }
-    const pluginsConfiguration = (0, nx_json_1.readNxJson)().plugins ?? [];
-    const [result, cleanupFn] = await (0, internal_api_1.loadNxPluginsInIsolation)(pluginsConfiguration, workspace_root_1.workspaceRoot);
-    cleanup = cleanupFn;
-    return result;
-}
-exports.getPlugins = getPlugins;
-function cleanupPlugins() {
-    cleanup();
-}
-exports.cleanupPlugins = cleanupPlugins;

package/src/project-graph/plugins/index.d.ts

@@ -1,2 +0,0 @@
-export * from './public-api';
-export { readPluginPackageJson, registerPluginTSTranspiler, } from './worker-api';

package/src/project-graph/plugins/index.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerPluginTSTranspiler = exports.readPluginPackageJson = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./public-api"), exports);
-var worker_api_1 = require("./worker-api");
-Object.defineProperty(exports, "readPluginPackageJson", { enumerable: true, get: function () { return worker_api_1.readPluginPackageJson; } });
-Object.defineProperty(exports, "registerPluginTSTranspiler", { enumerable: true, get: function () { return worker_api_1.registerPluginTSTranspiler; } });

package/src/project-graph/plugins/internal-api.d.ts

@@ -1,22 +0,0 @@
-import { PluginConfiguration } from '../../config/nx-json';
-import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
-import { CreateNodesContext, CreateNodesResult, NxPluginV2 } from './public-api';
-export { loadPlugins, loadPlugin } from './worker-api';
-export type CreateNodesResultWithContext = CreateNodesResult & {
-    file: string;
-    pluginName: string;
-};
-export type NormalizedPlugin = NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
-export type RemotePlugin = Omit<NormalizedPlugin, 'createNodes'> & {
-    createNodes: [
-        filePattern: string,
-        fn: (matchedFiles: string[], context: CreateNodesContext) => Promise<CreateNodesResultWithContext[]>
-    ];
-};
-export declare const nxPluginCache: Map<unknown, [Promise<RemotePlugin>, () => void]>;
-/**
- * This loads plugins in isolation in their own worker so that they do not disturb other workers or the main process.
- */
-export declare function loadNxPluginsInIsolation(plugins: PluginConfiguration[], root?: string): Promise<[RemotePlugin[], () => void]>;
-export declare function loadNxPluginInIsolation(plugin: PluginConfiguration, root?: string): [Promise<RemotePlugin>, () => void];
-export declare function getDefaultPlugins(root: string): Promise<string[]>;