@ohos-ports/nx 17.3.2-beta.0

package/src/plugins/target-defaults/target-defaults-plugin.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TargetDefaultsPlugin = exports.ONLY_MODIFIES_EXISTING_TARGET = void 0;
+const minimatch_1 = require("minimatch");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const fileutils_1 = require("../../utils/fileutils");
+const globs_1 = require("../../utils/globs");
+const package_json_workspaces_1 = require("../package-json-workspaces");
+/**
+ * This symbol marks that a target provides information which should modify a target already registered
+ * on the project via other plugins. If the target has not already been registered, and this symbol is true,
+ * the information provided by it will be discarded.
+ */
+exports.ONLY_MODIFIES_EXISTING_TARGET = Symbol('ONLY_MODIFIES_EXISTING_TARGET');
+exports.TargetDefaultsPlugin = {
+    name: 'nx/core/target-defaults',
+    createNodes: [
+        '{package.json,**/package.json,project.json,**/project.json}',
+        (configFile, _, ctx) => {
+            const fileName = (0, node_path_1.basename)(configFile);
+            const root = (0, node_path_1.dirname)(configFile);
+            const packageManagerWorkspacesGlob = (0, globs_1.combineGlobPatterns)((0, package_json_workspaces_1.getGlobPatternsFromPackageManagerWorkspaces)(ctx.workspaceRoot));
+            // Only process once if package.json + project.json both exist
+            if (fileName === 'package.json' &&
+                (0, node_fs_1.existsSync)((0, node_path_1.join)(ctx.workspaceRoot, root, 'project.json'))) {
+                return {};
+            }
+            else if (fileName === 'package.json' &&
+                !(0, minimatch_1.minimatch)(configFile, packageManagerWorkspacesGlob)) {
+                return {};
+            }
+            // If no target defaults, this does nothing
+            const targetDefaults = ctx.nxJsonConfiguration?.targetDefaults;
+            if (!targetDefaults) {
+                return {};
+            }
+            const projectJson = readJsonOrNull((0, node_path_1.join)(ctx.workspaceRoot, root, 'project.json'));
+            const packageJson = readJsonOrNull((0, node_path_1.join)(ctx.workspaceRoot, root, 'package.json'));
+            const includedScripts = packageJson?.nx?.includedScripts;
+            const projectDefinedTargets = new Set([
+                ...Object.keys(packageJson?.scripts ?? {}).filter((script) => {
+                    if (includedScripts) {
+                        return includedScripts.includes(script);
+                    }
+                    return true;
+                }),
+                ...Object.keys(projectJson?.targets ?? {}),
+                ...Object.keys(packageJson?.nx?.targets ?? {}),
+            ]);
+            const executorToTargetMap = getExecutorToTargetMap(packageJson, projectJson);
+            const modifiedTargets = {};
+            for (const defaultSpecifier in targetDefaults) {
+                const targetNames = executorToTargetMap.get(defaultSpecifier) ?? new Set();
+                targetNames.add(defaultSpecifier);
+                for (const targetName of targetNames) {
+                    // Prevents `build` from overwriting `@nx/js:tsc` if both are present
+                    // and build is specified later in the ordering.
+                    if (!modifiedTargets[targetName] || targetName !== defaultSpecifier) {
+                        modifiedTargets[targetName] = JSON.parse(JSON.stringify(targetDefaults[defaultSpecifier]));
+                    }
+                    // TODO: Remove this after we figure out a way to define new targets
+                    // in target defaults
+                    if (!projectDefinedTargets.has(targetName)) {
+                        modifiedTargets[targetName][exports.ONLY_MODIFIES_EXISTING_TARGET] = true;
+                    }
+                }
+            }
+            return {
+                projects: {
+                    [root]: {
+                        targets: modifiedTargets,
+                    },
+                },
+            };
+        },
+    ],
+};
+function getExecutorToTargetMap(packageJson, projectJson) {
+    const executorToTargetMap = new Map();
+    const targets = Object.keys({
+        ...projectJson?.targets,
+        ...packageJson?.scripts,
+        ...packageJson?.nx?.targets,
+    });
+    for (const target of targets) {
+        const executor = projectJson?.targets?.[target]?.executor ??
+            packageJson?.nx?.targets?.[target]?.executor ??
+            'nx:run-script';
+        const targetsForExecutor = executorToTargetMap.get(executor) ?? new Set();
+        targetsForExecutor.add(target);
+        executorToTargetMap.set(executor, targetsForExecutor);
+    }
+    return executorToTargetMap;
+}
+function readJsonOrNull(path) {
+    if ((0, node_fs_1.existsSync)(path)) {
+        return (0, fileutils_1.readJsonFile)(path);
+    }
+    else {
+        return null;
+    }
+}

package/src/project-graph/affected/affected-project-graph-models.d.ts

@@ -0,0 +1,11 @@
+import type { Change, FileChange } from '../file-utils';
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { ProjectGraph, ProjectGraphProjectNode } from '../../config/project-graph';
+export interface AffectedProjectGraphContext {
+    projectGraphNodes: Record<string, ProjectGraphProjectNode>;
+    nxJson: NxJsonConfiguration<any>;
+    touchedProjects: string[];
+}
+export interface TouchedProjectLocator<T extends Change = Change> {
+    (fileChanges: FileChange<T>[], projectGraphNodes?: Record<string, ProjectGraphProjectNode>, nxJson?: NxJsonConfiguration<any>, packageJson?: any, projectGraph?: ProjectGraph): string[] | Promise<string[]>;
+}

package/src/project-graph/affected/affected-project-graph-models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+import { FileChange } from '../file-utils';
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { ProjectGraph } from '../../config/project-graph';
+export declare function filterAffected(graph: ProjectGraph, touchedFiles: FileChange[], nxJson?: NxJsonConfiguration, packageJson?: any): Promise<ProjectGraph>;

package/src/project-graph/affected/affected-project-graph.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterAffected = void 0;
+const file_utils_1 = require("../file-utils");
+const workspace_projects_1 = require("./locators/workspace-projects");
+const touched_projects_1 = require("../../plugins/js/project-graph/affected/touched-projects");
+const operators_1 = require("../operators");
+const configuration_1 = require("../../config/configuration");
+const project_glob_changes_1 = require("./locators/project-glob-changes");
+async function filterAffected(graph, touchedFiles, nxJson = (0, configuration_1.readNxJson)(), packageJson = (0, file_utils_1.readPackageJson)()) {
+    // Additional affected logic should be in this array.
+    const touchedProjectLocators = [
+        workspace_projects_1.getTouchedProjects,
+        workspace_projects_1.getImplicitlyTouchedProjects,
+        project_glob_changes_1.getTouchedProjectsFromProjectGlobChanges,
+        touched_projects_1.getTouchedProjects,
+    ];
+    const touchedProjects = [];
+    for (const locator of touchedProjectLocators) {
+        const projects = await locator(touchedFiles, graph.nodes, nxJson, packageJson, graph);
+        touchedProjects.push(...projects);
+    }
+    return filterAffectedProjects(graph, {
+        projectGraphNodes: graph.nodes,
+        nxJson,
+        touchedProjects,
+    });
+}
+exports.filterAffected = filterAffected;
+// -----------------------------------------------------------------------------
+function filterAffectedProjects(graph, ctx) {
+    const result = {
+        nodes: {},
+        externalNodes: {},
+        dependencies: {},
+    };
+    const reversed = (0, operators_1.reverse)(graph);
+    ctx.touchedProjects.forEach((p) => {
+        addAffectedNodes(p, reversed, result, []);
+    });
+    ctx.touchedProjects.forEach((p) => {
+        addAffectedDependencies(p, reversed, result, []);
+    });
+    return result;
+}
+function addAffectedNodes(startingProject, reversed, result, visited) {
+    if (visited.indexOf(startingProject) > -1)
+        return;
+    const reversedNode = reversed.nodes[startingProject];
+    const reversedExternalNode = reversed.externalNodes[startingProject];
+    if (!reversedNode && !reversedExternalNode) {
+        throw new Error(`Invalid project name is detected: "${startingProject}"`);
+    }
+    visited.push(startingProject);
+    if (reversedNode) {
+        result.nodes[startingProject] = reversedNode;
+        result.dependencies[startingProject] = [];
+    }
+    else {
+        result.externalNodes[startingProject] = reversedExternalNode;
+    }
+    reversed.dependencies[startingProject]?.forEach(({ target }) => addAffectedNodes(target, reversed, result, visited));
+}
+function addAffectedDependencies(startingProject, reversed, result, visited) {
+    if (visited.indexOf(startingProject) > -1)
+        return;
+    visited.push(startingProject);
+    if (reversed.dependencies[startingProject]) {
+        reversed.dependencies[startingProject].forEach(({ target }) => addAffectedDependencies(target, reversed, result, visited));
+        reversed.dependencies[startingProject].forEach(({ type, source, target }) => {
+            // Since source and target was reversed,
+            // we need to reverse it back to original direction.
+            if (!result.dependencies[target]) {
+                result.dependencies[target] = [];
+            }
+            result.dependencies[target].push({
+                type,
+                source: target,
+                target: source,
+            });
+        });
+    }
+}

package/src/project-graph/affected/locators/project-glob-changes.d.ts

@@ -0,0 +1,2 @@
+import { TouchedProjectLocator } from '../affected-project-graph-models';
+export declare const getTouchedProjectsFromProjectGlobChanges: TouchedProjectLocator;

package/src/project-graph/affected/locators/project-glob-changes.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTouchedProjectsFromProjectGlobChanges = void 0;
+const minimatch_1 = require("minimatch");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const installation_directory_1 = require("../../../utils/installation-directory");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const retrieve_workspace_files_1 = require("../../utils/retrieve-workspace-files");
+const nx_plugin_1 = require("../../../utils/nx-plugin");
+const globs_1 = require("../../../utils/globs");
+const getTouchedProjectsFromProjectGlobChanges = async (touchedFiles, projectGraphNodes, nxJson) => {
+    const globPattern = (0, globs_1.combineGlobPatterns)((0, retrieve_workspace_files_1.configurationGlobs)(await (0, nx_plugin_1.loadNxPlugins)(nxJson?.plugins, (0, installation_directory_1.getNxRequirePaths)(workspace_root_1.workspaceRoot), workspace_root_1.workspaceRoot)));
+    const touchedProjects = new Set();
+    for (const touchedFile of touchedFiles) {
+        const isProjectFile = (0, minimatch_1.minimatch)(touchedFile.file, globPattern, {
+            dot: true,
+        });
+        if (isProjectFile) {
+            // If the file no longer exists on disk, then it was deleted
+            if (!(0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, touchedFile.file))) {
+                // If any project has been deleted, we must assume all projects were affected
+                return Object.keys(projectGraphNodes);
+            }
+            // Modified project config files are under a project's root, and implicitly
+            // mark it as affected. Thus, we don't need to handle it here.
+        }
+    }
+    return Array.from(touchedProjects);
+};
+exports.getTouchedProjectsFromProjectGlobChanges = getTouchedProjectsFromProjectGlobChanges;

package/src/project-graph/affected/locators/workspace-json-changes.d.ts

@@ -0,0 +1,4 @@
+import { WholeFileChange } from '../../file-utils';
+import { JsonChange } from '../../../utils/json-diff';
+import { TouchedProjectLocator } from '../affected-project-graph-models';
+export declare const getTouchedProjectsInWorkspaceJson: TouchedProjectLocator<WholeFileChange | JsonChange>;

package/src/project-graph/affected/locators/workspace-json-changes.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTouchedProjectsInWorkspaceJson = void 0;
+const file_utils_1 = require("../../file-utils");
+const json_diff_1 = require("../../../utils/json-diff");
+const getTouchedProjectsInWorkspaceJson = (touchedFiles, projectGraphNodes) => {
+    const workspaceChange = touchedFiles.find((change) => change.file === `angular.json`);
+    if (!workspaceChange) {
+        return [];
+    }
+    const changes = workspaceChange.getChanges();
+    if (changes.some((change) => {
+        if ((0, json_diff_1.isJsonChange)(change)) {
+            return change.path[0] !== 'projects';
+        }
+        if ((0, file_utils_1.isWholeFileChange)(change)) {
+            return true;
+        }
+        return false;
+    })) {
+        return Object.keys(projectGraphNodes);
+    }
+    const touched = [];
+    for (let i = 0; i < changes.length; i++) {
+        const change = changes[i];
+        if (!(0, json_diff_1.isJsonChange)(change) || change.path[0] !== 'projects') {
+            continue;
+        }
+        // Only look for changes that are changes to the whole project definition
+        if (change.path.length !== 2) {
+            continue;
+        }
+        switch (change.type) {
+            case json_diff_1.JsonDiffType.Deleted: {
+                // We are not sure which projects used to depend on a deleted project
+                // so return all projects to be safe
+                return Object.keys(projectGraphNodes);
+            }
+            default: {
+                // Add the project name
+                touched.push(change.path[1]);
+            }
+        }
+    }
+    return touched;
+};
+exports.getTouchedProjectsInWorkspaceJson = getTouchedProjectsInWorkspaceJson;

package/src/project-graph/affected/locators/workspace-projects.d.ts

@@ -0,0 +1,5 @@
+import { TouchedProjectLocator } from '../affected-project-graph-models';
+import { NxJsonConfiguration } from '../../../config/nx-json';
+export declare const getTouchedProjects: TouchedProjectLocator;
+export declare const getImplicitlyTouchedProjects: TouchedProjectLocator;
+export declare function extractGlobalFilesFromInputs(nxJson: NxJsonConfiguration): any[];

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractGlobalFilesFromInputs = exports.getImplicitlyTouchedProjects = exports.getTouchedProjects = void 0;
+const minimatch_1 = require("minimatch");
+const find_project_for_path_1 = require("../../utils/find-project-for-path");
+const getTouchedProjects = (touchedFiles, projectGraphNodes) => {
+    const projectRootMap = (0, find_project_for_path_1.createProjectRootMappings)(projectGraphNodes);
+    return touchedFiles.reduce((affected, f) => {
+        const matchingProject = (0, find_project_for_path_1.findProjectForPath)(f.file, projectRootMap);
+        if (matchingProject) {
+            affected.push(matchingProject);
+        }
+        return affected;
+    }, []);
+};
+exports.getTouchedProjects = getTouchedProjects;
+const getImplicitlyTouchedProjects = (fileChanges, projectGraphNodes, nxJson) => {
+    const implicits = {};
+    const globalFiles = [...extractGlobalFilesFromInputs(nxJson), 'nx.json'];
+    globalFiles.forEach((file) => {
+        implicits[file] = '*';
+    });
+    Object.values(projectGraphNodes || {}).forEach((node) => {
+        [
+            ...extractFilesFromNamedInputs(node.data.namedInputs),
+            ...extractFilesFromTargetInputs(node.data.targets),
+        ].forEach((input) => {
+            implicits[input] ??= [];
+            if (Array.isArray(implicits[input])) {
+                implicits[input].push(node.name);
+            }
+        });
+    });
+    const touched = new Set();
+    for (const [pattern, projects] of Object.entries(implicits)) {
+        const implicitDependencyWasChanged = fileChanges.some((f) => (0, minimatch_1.minimatch)(f.file, pattern, { dot: true }));
+        if (!implicitDependencyWasChanged) {
+            continue;
+        }
+        // File change affects all projects, just return all projects.
+        if (projects === '*') {
+            return Object.keys(projectGraphNodes);
+        }
+        else if (Array.isArray(projects)) {
+            projects.forEach((project) => touched.add(project));
+        }
+    }
+    return Array.from(touched);
+};
+exports.getImplicitlyTouchedProjects = getImplicitlyTouchedProjects;
+function extractGlobalFilesFromInputs(nxJson) {
+    const globalFiles = [];
+    globalFiles.push(...extractFilesFromNamedInputs(nxJson.namedInputs));
+    globalFiles.push(...extractFilesFromTargetInputs(nxJson.targetDefaults));
+    return globalFiles;
+}
+exports.extractGlobalFilesFromInputs = extractGlobalFilesFromInputs;
+function extractFilesFromNamedInputs(namedInputs) {
+    const files = [];
+    for (const inputs of Object.values(namedInputs || {})) {
+        files.push(...extractFilesFromInputs(inputs));
+    }
+    return files;
+}
+function extractFilesFromTargetInputs(targets) {
+    const globalFiles = [];
+    for (const target of Object.values(targets || {})) {
+        if (target.inputs) {
+            globalFiles.push(...extractFilesFromInputs(target.inputs));
+        }
+    }
+    return globalFiles;
+}
+function extractFilesFromInputs(inputs) {
+    const globalFiles = [];
+    for (const input of inputs) {
+        if (typeof input === 'string' && input.startsWith('{workspaceRoot}/')) {
+            globalFiles.push(input.substring('{workspaceRoot}/'.length));
+        }
+        else if (input.fileset && input.fileset.startsWith('{workspaceRoot}/')) {
+            globalFiles.push(input.fileset.substring('{workspaceRoot}/'.length));
+        }
+    }
+    return globalFiles;
+}

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

@@ -0,0 +1,14 @@
+import { FileData } from './file-utils';
+import { FileMapCache } from './nx-deps-cache';
+import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/project-graph';
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { NxWorkspaceFilesExternals } from '../native';
+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, shouldWriteCache: boolean): Promise<{
+    projectGraph: ProjectGraph;
+    projectFileMapCache: FileMapCache;
+}>;

package/src/project-graph/build-project-graph.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProjectGraphUsingProjectFileMap = exports.getFileMap = void 0;
+const workspace_root_1 = require("../utils/workspace-root");
+const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
+const assert_workspace_validity_1 = require("../utils/assert-workspace-validity");
+const nx_deps_cache_1 = require("./nx-deps-cache");
+const implicit_project_dependencies_1 = require("./utils/implicit-project-dependencies");
+const normalize_project_nodes_1 = require("./utils/normalize-project-nodes");
+const nx_plugin_1 = require("../utils/nx-plugin");
+const typescript_1 = require("../plugins/js/utils/typescript");
+const fileutils_1 = require("../utils/fileutils");
+const project_graph_builder_1 = require("./project-graph-builder");
+const configuration_1 = require("../config/configuration");
+const fs_1 = require("fs");
+const installation_directory_1 = require("../utils/installation-directory");
+const output_1 = require("../utils/output");
+let storedFileMap = null;
+let storedAllWorkspaceFiles = null;
+let storedRustReferences = null;
+function getFileMap() {
+    if (!!storedFileMap) {
+        return {
+            fileMap: storedFileMap,
+            allWorkspaceFiles: storedAllWorkspaceFiles,
+            rustReferences: storedRustReferences,
+        };
+    }
+    else {
+        return {
+            fileMap: {
+                nonProjectFiles: [],
+                projectFileMap: {},
+            },
+            allWorkspaceFiles: [],
+            rustReferences: null,
+        };
+    }
+}
+exports.getFileMap = getFileMap;
+async function buildProjectGraphUsingProjectFileMap(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache, shouldWriteCache) {
+    storedFileMap = fileMap;
+    storedAllWorkspaceFiles = allWorkspaceFiles;
+    storedRustReferences = rustReferences;
+    const nxJson = (0, configuration_1.readNxJson)();
+    const projectGraphVersion = '6.0';
+    (0, assert_workspace_validity_1.assertWorkspaceValidity)(projects, nxJson);
+    const packageJsonDeps = readCombinedDeps();
+    const rootTsConfig = readRootTsConfig();
+    let filesToProcess;
+    let cachedFileData;
+    const useCacheData = fileMapCache &&
+        !(0, nx_deps_cache_1.shouldRecomputeWholeGraph)(fileMapCache, packageJsonDeps, projects, nxJson, rootTsConfig);
+    if (useCacheData) {
+        const fromCache = (0, nx_deps_cache_1.extractCachedFileData)(fileMap, fileMapCache);
+        filesToProcess = fromCache.filesToProcess;
+        cachedFileData = fromCache.cachedFileData;
+    }
+    else {
+        filesToProcess = fileMap;
+        cachedFileData = {
+            nonProjectFiles: {},
+            projectFileMap: {},
+        };
+    }
+    const context = createContext(projects, nxJson, externalNodes, fileMap, filesToProcess);
+    let projectGraph = await buildProjectGraphUsingContext(nxJson, externalNodes, context, cachedFileData, projectGraphVersion);
+    const projectFileMapCache = (0, nx_deps_cache_1.createProjectFileMapCache)(nxJson, packageJsonDeps, fileMap, rootTsConfig);
+    if (shouldWriteCache) {
+        (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph);
+    }
+    return {
+        projectGraph,
+        projectFileMapCache,
+    };
+}
+exports.buildProjectGraphUsingProjectFileMap = buildProjectGraphUsingProjectFileMap;
+function readCombinedDeps() {
+    const installationPackageJsonPath = (0, path_1.join)(workspace_root_1.workspaceRoot, '.nx', 'installation', 'package.json');
+    const installationPackageJson = (0, fs_1.existsSync)(installationPackageJsonPath)
+        ? (0, fileutils_1.readJsonFile)(installationPackageJsonPath)
+        : {};
+    const rootPackageJsonPath = (0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json');
+    const rootPackageJson = (0, fs_1.existsSync)(rootPackageJsonPath)
+        ? (0, fileutils_1.readJsonFile)(rootPackageJsonPath)
+        : {};
+    return {
+        ...rootPackageJson.dependencies,
+        ...rootPackageJson.devDependencies,
+        ...installationPackageJson.dependencies,
+        ...installationPackageJson.devDependencies,
+    };
+}
+async function buildProjectGraphUsingContext(nxJson, knownExternalNodes, ctx, cachedFileData, projectGraphVersion) {
+    perf_hooks_1.performance.mark('build project graph:start');
+    const builder = new project_graph_builder_1.ProjectGraphBuilder(null, ctx.fileMap.projectFileMap);
+    builder.setVersion(projectGraphVersion);
+    for (const node in knownExternalNodes) {
+        builder.addExternalNode(knownExternalNodes[node]);
+    }
+    await (0, normalize_project_nodes_1.normalizeProjectNodes)(ctx, builder);
+    const initProjectGraph = builder.getUpdatedProjectGraph();
+    const r = await updateProjectGraphWithPlugins(ctx, initProjectGraph);
+    const updatedBuilder = new project_graph_builder_1.ProjectGraphBuilder(r, ctx.fileMap.projectFileMap);
+    for (const proj of Object.keys(cachedFileData.projectFileMap)) {
+        for (const f of ctx.fileMap.projectFileMap[proj] || []) {
+            const cached = cachedFileData.projectFileMap[proj][f.file];
+            if (cached && cached.deps) {
+                f.deps = [...cached.deps];
+            }
+        }
+    }
+    for (const file of ctx.fileMap.nonProjectFiles) {
+        const cached = cachedFileData.nonProjectFiles[file.file];
+        if (cached?.deps) {
+            file.deps = [...cached.deps];
+        }
+    }
+    (0, implicit_project_dependencies_1.applyImplicitDependencies)(ctx.projects, updatedBuilder);
+    const finalGraph = updatedBuilder.getUpdatedProjectGraph();
+    perf_hooks_1.performance.mark('build project graph:end');
+    perf_hooks_1.performance.measure('build project graph', 'build project graph:start', 'build project graph:end');
+    return finalGraph;
+}
+function createContext(projects, nxJson, externalNodes, fileMap, filesToProcess) {
+    const clonedProjects = Object.keys(projects).reduce((map, projectName) => {
+        map[projectName] = {
+            ...projects[projectName],
+        };
+        return map;
+    }, {});
+    return {
+        nxJsonConfiguration: nxJson,
+        projects: clonedProjects,
+        externalNodes,
+        workspaceRoot: workspace_root_1.workspaceRoot,
+        fileMap,
+        filesToProcess,
+    };
+}
+async function updateProjectGraphWithPlugins(context, initProjectGraph) {
+    const plugins = await (0, nx_plugin_1.loadNxPlugins)(context.nxJsonConfiguration?.plugins, (0, installation_directory_1.getNxRequirePaths)(), context.workspaceRoot, context.projects);
+    let graph = initProjectGraph;
+    for (const { plugin } of plugins) {
+        try {
+            if ((0, nx_plugin_1.isNxPluginV1)(plugin) &&
+                plugin.processProjectGraph &&
+                !plugin.createDependencies) {
+                output_1.output.warn({
+                    title: `${plugin.name} is a v1 plugin.`,
+                    bodyLines: [
+                        'Nx has recently released a v2 model for project graph plugins. The `processProjectGraph` method is deprecated. Plugins should use some combination of `createNodes` and `createDependencies` instead.',
+                    ],
+                });
+                perf_hooks_1.performance.mark(`${plugin.name}:processProjectGraph - start`);
+                graph = await plugin.processProjectGraph(graph, {
+                    ...context,
+                    projectsConfigurations: {
+                        projects: context.projects,
+                        version: 2,
+                    },
+                    fileMap: context.fileMap.projectFileMap,
+                    filesToProcess: context.filesToProcess.projectFileMap,
+                    workspace: {
+                        version: 2,
+                        projects: context.projects,
+                        ...context.nxJsonConfiguration,
+                    },
+                });
+                perf_hooks_1.performance.mark(`${plugin.name}:processProjectGraph - end`);
+                perf_hooks_1.performance.measure(`${plugin.name}:processProjectGraph`, `${plugin.name}:processProjectGraph - start`, `${plugin.name}:processProjectGraph - end`);
+            }
+        }
+        catch (e) {
+            let message = `Failed to process the project graph with "${plugin.name}".`;
+            if (e instanceof Error) {
+                e.message = message + '\n' + e.message;
+                throw e;
+            }
+            throw new Error(message);
+        }
+    }
+    const builder = new project_graph_builder_1.ProjectGraphBuilder(graph, context.fileMap.projectFileMap, context.fileMap.nonProjectFiles);
+    const createDependencyPlugins = plugins.filter(({ plugin }) => (0, nx_plugin_1.isNxPluginV2)(plugin) && plugin.createDependencies);
+    await Promise.all(createDependencyPlugins.map(async ({ plugin, options }) => {
+        perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - start`);
+        try {
+            const dependencies = await plugin.createDependencies(options, {
+                ...context,
+            });
+            for (const dep of dependencies) {
+                builder.addDependency(dep.source, dep.target, dep.type, 'sourceFile' in dep ? dep.sourceFile : null);
+            }
+        }
+        catch (e) {
+            let message = `Failed to process project dependencies with "${plugin.name}".`;
+            if (e instanceof Error) {
+                e.message = message + '\n' + e.message;
+                throw e;
+            }
+            throw new Error(message);
+        }
+        perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - end`);
+        perf_hooks_1.performance.measure(`${plugin.name}:createDependencies`, `${plugin.name}:createDependencies - start`, `${plugin.name}:createDependencies - end`);
+    }));
+    return builder.getUpdatedProjectGraph();
+}
+function readRootTsConfig() {
+    try {
+        const tsConfigPath = (0, typescript_1.getRootTsConfigPath)();
+        if (tsConfigPath) {
+            return (0, fileutils_1.readJsonFile)(tsConfigPath, { expectComments: true });
+        }
+    }
+    catch (e) {
+        return {};
+    }
+}

package/src/project-graph/file-map-utils.d.ts

@@ -0,0 +1,15 @@
+import { FileData, FileMap, ProjectFileMap, ProjectGraph } from '../config/project-graph';
+import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
+import { NxWorkspaceFilesExternals } from '../native';
+export interface WorkspaceFileMap {
+    allWorkspaceFiles: FileData[];
+    fileMap: FileMap;
+}
+export declare function createProjectFileMapUsingProjectGraph(graph: ProjectGraph): Promise<ProjectFileMap>;
+export declare function createFileMapUsingProjectGraph(graph: ProjectGraph): Promise<WorkspaceFileMap>;
+export declare function createFileMap(projectsConfigurations: ProjectsConfigurations, allWorkspaceFiles: FileData[]): WorkspaceFileMap;
+export declare function updateFileMap(projectsConfigurations: Record<string, ProjectConfiguration>, rustReferences: NxWorkspaceFilesExternals, updatedFiles: Record<string, string>, deletedFiles: string[]): {
+    fileMap: import("../native").FileMap;
+    allWorkspaceFiles: FileData[];
+    rustReferences: NxWorkspaceFilesExternals;
+};