nx 19.0.0-beta.0 → 19.0.0-beta.10

package/src/executors/run-commands/schema.json

@@ -100,8 +100,15 @@
     },
     "args": {
       "oneOf": [
-        { "type": "array", "items": { "type": "string" } },
-        { "type": "string" }
+        {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        {
+          "type": "string"
+        }
       ],
       "description": "Extra arguments. You can pass them as follows: nx run project:target --args='--wait=100'. You can then use {args.wait} syntax to interpolate them in the workspace config file. See example [above](#chaining-commands-interpolating-args-and-setting-the-cwd)"
     },
@@ -135,6 +142,16 @@
         "$source": "unparsed"
       },
       "x-priority": "internal"
+    },
+    "forwardAllArgs": {
+      "type": "boolean",
+      "description": "Whether arguments should be forwarded when interpolation is not present.",
+      "default": true
+    },
+    "tty": {
+      "type": "boolean",
+      "description": "Whether commands should be run with a tty terminal",
+      "hidden": true
     }
   },
   "additionalProperties": true,

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertNxExecutor = void 0;
 const nx_json_1 = require("../../config/nx-json");
 const retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
+const project_configuration_utils_1 = require("../../project-graph/utils/project-configuration-utils");
 const internal_api_1 = require("../../project-graph/plugins/internal-api");
 /**
  * Convert an Nx Executor into an Angular Devkit Builder
@@ -19,7 +20,7 @@ function convertNxExecutor(executor) {
             const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)(nxJsonConfiguration.plugins, builderContext.workspaceRoot);
             const projectsConfigurations = {
                 version: 2,
-                projects: (await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, builderContext.workspaceRoot, nxJsonConfiguration)).projects,
+                projects: (0, project_configuration_utils_1.readProjectConfigurationsFromRootMap)((await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, builderContext.workspaceRoot, nxJsonConfiguration)).projects),
             };
             cleanup();
             const context = {

package/src/generators/testing-utils/create-tree-with-empty-workspace.js

@@ -2,11 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTreeWithEmptyV1Workspace = exports.createTreeWithEmptyWorkspace = void 0;
 const tree_1 = require("../tree");
+const workspace_root_1 = require("../../utils/workspace-root");
 /**
  * Creates a host for testing.
  */
 function createTreeWithEmptyWorkspace(opts = {}) {
     const tree = new tree_1.FsTree('/virtual', false);
+    // Our unit tests are all written as though they are at the root of a workspace
+    // However, when they are run in a subdirectory of the workspaceRoot,
+    // the relative path between workspaceRoot and the directory the tests are run
+    // is prepended to the paths created in the virtual tree.
+    // Setting this envVar to workspaceRoot prevents this behaviour
+    process.env.INIT_CWD = workspace_root_1.workspaceRoot;
     return addCommonFiles(tree, opts.layout === 'apps-libs');
 }
 exports.createTreeWithEmptyWorkspace = createTreeWithEmptyWorkspace;

package/src/generators/utils/project-configuration.js

@@ -7,7 +7,6 @@ const package_json_workspaces_1 = require("../../plugins/package-json-workspaces
 const project_json_1 = require("../../plugins/project-json/build-nodes/project-json");
 const angular_json_1 = require("../../adapter/angular-json");
 const project_configuration_utils_1 = require("../../project-graph/utils/project-configuration-utils");
-const retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
 const workspace_context_1 = require("../../utils/workspace-context");
 const output_1 = require("../../utils/output");
 const path_2 = require("../../utils/path");
@@ -135,15 +134,11 @@ function readAndCombineAllProjectConfigurations(tree) {
         'project.json',
         ...(0, package_json_workspaces_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (p) => (0, json_1.readJson)(tree, p, { expectComments: true })),
     ];
-    const projectGlobPatterns = (0, retrieve_workspace_files_1.configurationGlobs)([
-        project_json_1.ProjectJsonProjectsPlugin,
-        { createNodes: package_json_workspaces_1.createNodes },
-    ]);
-    const globbedFiles = (0, workspace_context_1.globWithWorkspaceContext)(tree.root, projectGlobPatterns);
+    const globbedFiles = (0, workspace_context_1.globWithWorkspaceContext)(tree.root, patterns);
     const createdFiles = findCreatedProjectFiles(tree, patterns);
     const deletedFiles = findDeletedProjectFiles(tree, patterns);
     const projectFiles = [...globbedFiles, ...createdFiles].filter((r) => deletedFiles.indexOf(r) === -1);
-    const rootMap = new Map();
+    const rootMap = {};
     for (const projectFile of projectFiles) {
         if ((0, path_1.basename)(projectFile) === 'project.json') {
             const json = (0, json_1.readJson)(tree, projectFile);
@@ -153,7 +148,7 @@ function readAndCombineAllProjectConfigurations(tree) {
         else if ((0, path_1.basename)(projectFile) === 'package.json') {
             const packageJson = (0, json_1.readJson)(tree, projectFile);
             const config = (0, package_json_workspaces_1.buildProjectConfigurationFromPackageJson)(packageJson, projectFile, (0, nx_json_1.readNxJson)(tree));
-            if (!rootMap.has(config.root)) {
+            if (!rootMap[config.root]) {
                 (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, 
                 // Inferred targets, tags, etc don't show up when running generators
                 // This is to help avoid running into issues when trying to update the workspace

package/src/hasher/task-hasher.d.ts

@@ -34,22 +34,22 @@ export interface Hash {
 }
 export interface TaskHasher {
     /**
-     * @deprecated use hashTask(task:Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v19
+     * @deprecated use hashTask(task:Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
      * @param task
      */
     hashTask(task: Task): Promise<Hash>;
     /**
-     * @deprecated use hashTask(task:Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v19
+     * @deprecated use hashTask(task:Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
      */
     hashTask(task: Task, taskGraph: TaskGraph): Promise<Hash>;
     hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<Hash>;
     /**
-     *  @deprecated use hashTasks(tasks:Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v19
+     *  @deprecated use hashTasks(tasks:Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
      * @param tasks
      */
     hashTasks(tasks: Task[]): Promise<Hash[]>;
     /**
-     * @deprecated use hashTasks(tasks:Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v19
+     * @deprecated use hashTasks(tasks:Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
      */
     hashTasks(tasks: Task[], taskGraph: TaskGraph): Promise<Hash[]>;
     hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<Hash[]>;

package/src/native/index.d.ts

@@ -150,7 +150,7 @@ export class ChildProcess {
 }
 export class RustPseudoTerminal {
   constructor()
-  runCommand(command: string, commandDir?: string | undefined | null, jsEnv?: Record<string, string> | undefined | null, quiet?: boolean | undefined | null): ChildProcess
+  runCommand(command: string, commandDir?: string | undefined | null, jsEnv?: Record<string, string> | undefined | null, quiet?: boolean | undefined | null, tty?: boolean | undefined | null): ChildProcess
   /**
    * This allows us to run a pseudoterminal with a fake node ipc channel
    * this makes it possible to be backwards compatible with the old implementation

package/src/plugins/js/lock-file/pnpm-parser.js

@@ -33,39 +33,127 @@ function getPnpmLockfileDependencies(lockFileContent, lockFileHash, ctx) {
     return getDependencies(data, keyMap, isV6, ctx);
 }
 exports.getPnpmLockfileDependencies = getPnpmLockfileDependencies;
+function matchPropValue(record, key, originalPackageName) {
+    if (!record) {
+        return undefined;
+    }
+    const index = Object.values(record).findIndex((version) => version === key);
+    if (index > -1) {
+        return Object.keys(record)[index];
+    }
+    // check if non-aliased name is found
+    if (record[originalPackageName] &&
+        key.startsWith(`/${originalPackageName}/${record[originalPackageName]}`)) {
+        return originalPackageName;
+    }
+}
+function matchedDependencyName(importer, key, originalPackageName) {
+    return (matchPropValue(importer.dependencies, key, originalPackageName) ||
+        matchPropValue(importer.optionalDependencies, key, originalPackageName) ||
+        matchPropValue(importer.peerDependencies, key, originalPackageName));
+}
+function createHashFromSnapshot(snapshot) {
+    return (snapshot.resolution?.['integrity'] ||
+        (snapshot.resolution?.['tarball']
+            ? (0, file_hasher_1.hashArray)([snapshot.resolution['tarball']])
+            : undefined));
+}
+function isLockFileKey(depVersion) {
+    return depVersion.startsWith('/');
+}
 function getNodes(data, keyMap, isV6) {
     const nodes = new Map();
-    Object.entries(data.packages).forEach(([key, snapshot]) => {
-        findPackageNames(key, snapshot, data).forEach((packageName) => {
-            const rawVersion = findVersion(key, packageName);
-            const version = parseBaseVersion(rawVersion, isV6);
-            // we don't need to keep duplicates, we can just track the keys
-            const existingNode = nodes.get(packageName)?.get(version);
-            if (existingNode) {
-                keyMap.set(key, existingNode);
-                return;
+    const maybeAliasedPackageVersions = new Map(); // <version, alias>
+    const packageNames = new Set();
+    for (const [key, snapshot] of Object.entries(data.packages)) {
+        const originalPackageName = extractNameFromKey(key);
+        if (!originalPackageName) {
+            continue;
+        }
+        // snapshot already has a name
+        if (snapshot.name) {
+            packageNames.add({
+                key,
+                packageName: snapshot.name,
+                hash: createHashFromSnapshot(snapshot),
+            });
+        }
+        const rootDependencyName = matchedDependencyName(data.importers['.'], key, originalPackageName) ||
+            // only root importers have devDependencies
+            matchPropValue(data.importers['.'].devDependencies, key, originalPackageName);
+        if (rootDependencyName) {
+            packageNames.add({
+                key,
+                packageName: rootDependencyName,
+                hash: createHashFromSnapshot(snapshot),
+            });
+        }
+        if (!snapshot.name && !rootDependencyName) {
+            packageNames.add({
+                key,
+                packageName: originalPackageName,
+                hash: createHashFromSnapshot(snapshot),
+            });
+        }
+        if (snapshot.peerDependencies) {
+            for (const [depName, depVersion] of Object.entries(snapshot.peerDependencies)) {
+                if (isLockFileKey(depVersion)) {
+                    maybeAliasedPackageVersions.set(depVersion, depName);
+                }
+            }
+        }
+        if (snapshot.optionalDependencies) {
+            for (const [depName, depVersion] of Object.entries(snapshot.optionalDependencies)) {
+                if (isLockFileKey(depVersion)) {
+                    maybeAliasedPackageVersions.set(depVersion, depName);
+                }
             }
+        }
+        if (snapshot.dependencies) {
+            for (const [depName, depVersion] of Object.entries(snapshot.dependencies)) {
+                if (isLockFileKey(depVersion)) {
+                    maybeAliasedPackageVersions.set(depVersion, depName);
+                }
+            }
+        }
+        const aliasedDep = maybeAliasedPackageVersions.get(key);
+        if (aliasedDep) {
+            packageNames.add({
+                key,
+                packageName: aliasedDep,
+                hash: createHashFromSnapshot(snapshot),
+            });
+        }
+    }
+    for (const { key, packageName, hash } of packageNames) {
+        const rawVersion = findVersion(key, packageName);
+        if (!rawVersion) {
+            continue;
+        }
+        const version = parseBaseVersion(rawVersion, isV6);
+        if (!version) {
+            continue;
+        }
+        if (!nodes.has(packageName)) {
+            nodes.set(packageName, new Map());
+        }
+        if (!nodes.get(packageName).has(version)) {
             const node = {
                 type: 'npm',
                 name: version ? `npm:${packageName}@${version}` : `npm:${packageName}`,
                 data: {
                     version,
                     packageName,
-                    hash: snapshot.resolution?.['integrity'] ||
-                        (0, file_hasher_1.hashArray)(snapshot.resolution?.['tarball']
-                            ? [snapshot.resolution['tarball']]
-                            : [packageName, version]),
+                    hash: hash ?? (0, file_hasher_1.hashArray)([packageName, version]),
                 },
             };
+            nodes.get(packageName).set(version, node);
             keyMap.set(key, node);
-            if (!nodes.has(packageName)) {
-                nodes.set(packageName, new Map([[version, node]]));
-            }
-            else {
-                nodes.get(packageName).set(version, node);
-            }
-        });
-    });
+        }
+        else {
+            keyMap.set(key, nodes.get(packageName).get(version));
+        }
+    }
     const hoistedDeps = (0, pnpm_normalizer_1.loadPnpmHoistedDepsDefinition)();
     const results = {};
     for (const [packageName, versionMap] of nodes.entries()) {
@@ -228,52 +316,6 @@ function findVersion(key, packageName) {
     // for tarball package the entire key is the version spec
     return key;
 }
-function findPackageNames(key, snapshot, data) {
-    const packageNames = new Set();
-    const originalPackageName = extractNameFromKey(key);
-    const matchPropValue = (record) => {
-        if (!record) {
-            return undefined;
-        }
-        const index = Object.values(record).findIndex((version) => version === key);
-        if (index > -1) {
-            return Object.keys(record)[index];
-        }
-        // check if non aliased name is found
-        if (record[originalPackageName] &&
-            key.startsWith(`/${originalPackageName}/${record[originalPackageName]}`)) {
-            return originalPackageName;
-        }
-    };
-    const matchedDependencyName = (importer) => {
-        return (matchPropValue(importer.dependencies) ||
-            matchPropValue(importer.optionalDependencies) ||
-            matchPropValue(importer.peerDependencies));
-    };
-    // snapshot already has a name
-    if (snapshot.name) {
-        packageNames.add(snapshot.name);
-    }
-    // it'a a root dependency
-    const rootDependencyName = matchedDependencyName(data.importers['.']) ||
-        // only root importers have devDependencies
-        matchPropValue(data.importers['.'].devDependencies);
-    if (rootDependencyName) {
-        packageNames.add(rootDependencyName);
-    }
-    // find a snapshot that has a dependency that points to this snapshot
-    const snapshots = Object.values(data.packages);
-    for (let i = 0; i < snapshots.length; i++) {
-        const dependencyName = matchedDependencyName(snapshots[i]);
-        if (dependencyName) {
-            packageNames.add(dependencyName);
-        }
-    }
-    if (packageNames.size === 0) {
-        packageNames.add(originalPackageName);
-    }
-    return Array.from(packageNames);
-}
 function getVersion(key, packageName) {
     const KEY_NAME_SEPARATOR_LENGTH = 2; // leading and trailing slash
     return key.slice(packageName.length + KEY_NAME_SEPARATOR_LENGTH);

package/src/plugins/package-json-workspaces/create-nodes.d.ts

@@ -3,6 +3,7 @@ import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { PackageJson } from '../../utils/package-json';
 import { CreateNodes } from '../../project-graph/plugins';
 export declare const createNodes: CreateNodes;
+export declare function buildPackageJsonWorkspacesMatcher(workspaceRoot: string, readJson: (string: any) => any): (p: string) => boolean;
 export declare function createNodeFromPackageJson(pkgJsonPath: string, root: string): {
     projects: {
         [x: string]: ProjectConfiguration & {

package/src/plugins/package-json-workspaces/create-nodes.js

@@ -1,41 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGlobPatternsFromPackageManagerWorkspaces = exports.buildProjectConfigurationFromPackageJson = exports.createNodeFromPackageJson = exports.createNodes = void 0;
+exports.getGlobPatternsFromPackageManagerWorkspaces = exports.buildProjectConfigurationFromPackageJson = exports.createNodeFromPackageJson = exports.buildPackageJsonWorkspacesMatcher = exports.createNodes = void 0;
 const minimatch_1 = require("minimatch");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const nx_json_1 = require("../../config/nx-json");
-const workspaces_1 = require("../../config/workspaces");
+const to_project_name_1 = require("../../config/to-project-name");
 const fileutils_1 = require("../../utils/fileutils");
 const globs_1 = require("../../utils/globs");
 const logger_1 = require("../../utils/logger");
 const output_1 = require("../../utils/output");
 const package_json_1 = require("../../utils/package-json");
 const path_1 = require("../../utils/path");
-const workspace_root_1 = require("../../utils/workspace-root");
-const readJson = (f) => (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspace_root_1.workspaceRoot, f));
-const patterns = getGlobPatternsFromPackageManagerWorkspaces(workspace_root_1.workspaceRoot, readJson);
-const negativePatterns = patterns.filter((p) => p.startsWith('!'));
-const positivePatterns = patterns.filter((p) => !p.startsWith('!'));
-if (
-// There are some negative patterns
-negativePatterns.length > 0 &&
-    // No positive patterns
-    (positivePatterns.length === 0 ||
-        // Or only a single positive pattern that is the default coming from root package
-        (positivePatterns.length === 1 && positivePatterns[0] === 'package.json'))) {
-    positivePatterns.push('**/package.json');
-}
 exports.createNodes = [
-    (0, globs_1.combineGlobPatterns)(positivePatterns),
+    (0, globs_1.combineGlobPatterns)('package.json', '**/package.json'),
     (p, _, { workspaceRoot }) => {
-        if (!negativePatterns.some((negative) => (0, minimatch_1.minimatch)(p, negative))) {
+        const readJson = (f) => (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, f));
+        const matcher = buildPackageJsonWorkspacesMatcher(workspaceRoot, readJson);
+        if (matcher(p)) {
             return createNodeFromPackageJson(p, workspaceRoot);
         }
-        // A negative pattern matched, so we should not create a node for this package.json
+        // The given package.json is not part of the workspaces configuration.
         return {};
     },
 ];
+function buildPackageJsonWorkspacesMatcher(workspaceRoot, readJson) {
+    const patterns = getGlobPatternsFromPackageManagerWorkspaces(workspaceRoot, readJson);
+    const negativePatterns = patterns.filter((p) => p.startsWith('!'));
+    const positivePatterns = patterns.filter((p) => !p.startsWith('!'));
+    if (
+    // There are some negative patterns
+    negativePatterns.length > 0 &&
+        // No positive patterns
+        (positivePatterns.length === 0 ||
+            // Or only a single positive pattern that is the default coming from root package
+            (positivePatterns.length === 1 && positivePatterns[0] === 'package.json'))) {
+        positivePatterns.push('**/package.json');
+    }
+    return (p) => positivePatterns.some((positive) => (0, minimatch_1.minimatch)(p, positive)) &&
+        !negativePatterns.some((negative) => (0, minimatch_1.minimatch)(p, negative));
+}
+exports.buildPackageJsonWorkspacesMatcher = buildPackageJsonWorkspacesMatcher;
 function createNodeFromPackageJson(pkgJsonPath, root) {
     const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, pkgJsonPath));
     const project = buildProjectConfigurationFromPackageJson(json, pkgJsonPath, (0, nx_json_1.readNxJson)(root));
@@ -52,7 +57,7 @@ function buildProjectConfigurationFromPackageJson(packageJson, path, nxJson) {
     if (!packageJson.name && directory === '.') {
         throw new Error('Nx requires the root package.json to specify a name if it is being used as an Nx project.');
     }
-    let name = packageJson.name ?? (0, workspaces_1.toProjectName)(normalizedPath);
+    let name = packageJson.name ?? (0, to_project_name_1.toProjectName)(normalizedPath);
     const projectType = nxJson?.workspaceLayout?.appsDir != nxJson?.workspaceLayout?.libsDir &&
         nxJson?.workspaceLayout?.appsDir &&
         directory.startsWith(nxJson.workspaceLayout.appsDir)

package/src/plugins/project-json/build-nodes/project-json.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildProjectFromProjectJson = exports.ProjectJsonProjectsPlugin = void 0;
 const node_path_1 = require("node:path");
-const workspaces_1 = require("../../../config/workspaces");
+const to_project_name_1 = require("../../../config/to-project-name");
 const fileutils_1 = require("../../../utils/fileutils");
 exports.ProjectJsonProjectsPlugin = {
     name: 'nx/core/project-json',
@@ -22,7 +22,7 @@ exports.ProjectJsonProjectsPlugin = {
 exports.default = exports.ProjectJsonProjectsPlugin;
 function buildProjectFromProjectJson(json, path) {
     return {
-        name: (0, workspaces_1.toProjectName)(path),
+        name: (0, to_project_name_1.toProjectName)(path),
         root: (0, node_path_1.dirname)(path),
         ...json,
     };

package/src/project-graph/affected/locators/workspace-projects.js

@@ -15,7 +15,9 @@ const getTouchedProjects = (touchedFiles, projectGraphNodes) => {
 };
 exports.getTouchedProjects = getTouchedProjects;
 const getImplicitlyTouchedProjects = (fileChanges, projectGraphNodes, nxJson) => {
-    const implicits = {};
+    const implicits = {
+        'nx.json': '*',
+    };
     Object.values(projectGraphNodes || {}).forEach((node) => {
         const namedInputs = {
             ...nxJson.namedInputs,

package/src/project-graph/build-project-graph.d.ts

@@ -1,32 +1,22 @@
 import { FileData } from './file-utils';
 import { FileMapCache } from './nx-deps-cache';
 import { LoadedNxPlugin } from './plugins/internal-api';
+import { CreateMetadataContext } from './plugins';
 import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/project-graph';
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
 import { NxWorkspaceFilesExternals } from '../native';
+import { CreateMetadataError } from './error-types';
+import { ConfigurationSourceMaps } from './utils/project-configuration-utils';
 export declare function getFileMap(): {
     fileMap: FileMap;
     allWorkspaceFiles: FileData[];
     rustReferences: NxWorkspaceFilesExternals | null;
 };
-export declare function buildProjectGraphUsingProjectFileMap(projects: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, plugins: LoadedNxPlugin[]): Promise<{
+export declare function buildProjectGraphUsingProjectFileMap(projectRootMap: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, plugins: LoadedNxPlugin[], sourceMap: ConfigurationSourceMaps): Promise<{
     projectGraph: ProjectGraph;
     projectFileMapCache: FileMapCache;
 }>;
-export declare class ProcessDependenciesError extends Error {
-    readonly pluginName: string;
-    constructor(pluginName: string, { cause }: {
-        cause: any;
-    });
-}
-export declare class ProcessProjectGraphError extends Error {
-    readonly pluginName: string;
-    constructor(pluginName: string, { cause }: {
-        cause: any;
-    });
-}
-export declare class CreateDependenciesError extends Error {
-    readonly errors: Array<ProcessDependenciesError | ProcessProjectGraphError>;
-    readonly partialProjectGraph: ProjectGraph;
-    constructor(errors: Array<ProcessDependenciesError | ProcessProjectGraphError>, partialProjectGraph: ProjectGraph);
-}
+export declare function applyProjectMetadata(graph: ProjectGraph, plugins: LoadedNxPlugin[], context: CreateMetadataContext, sourceMap: ConfigurationSourceMaps): Promise<{
+    graph: ProjectGraph;
+    errors?: CreateMetadataError[];
+}>;