@depup/nx 22.5.4-depup.0

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

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodesV2 = void 0;
+exports.buildPackageJsonPatterns = buildPackageJsonPatterns;
+exports.buildPackageJsonWorkspacesMatcher = buildPackageJsonWorkspacesMatcher;
+exports.createNodeFromPackageJson = createNodeFromPackageJson;
+exports.buildProjectConfigurationFromPackageJson = buildProjectConfigurationFromPackageJson;
+exports.getGlobPatternsFromPackageManagerWorkspaces = getGlobPatternsFromPackageManagerWorkspaces;
+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 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 versions_1 = require("../../utils/versions");
+const plugins_1 = require("../../project-graph/plugins");
+const path_2 = require("path");
+const file_hasher_1 = require("../../hasher/file-hasher");
+const package_json_2 = require("../../../plugins/package-json");
+const globPatterns = (0, globs_1.combineGlobPatterns)('package.json', '**/package.json', 'project.json', '**/project.json');
+exports.createNodesV2 = [
+    globPatterns,
+    (configFiles, _, context) => {
+        const { packageJsons, projectJsonRoots } = splitConfigFiles(configFiles);
+        const readJson = (f) => (0, fileutils_1.readJsonFile)((0, node_path_1.join)(context.workspaceRoot, f));
+        let isInPackageJsonWorkspaces = (p) => true;
+        if (process.env.NX_INFER_ALL_PACKAGE_JSONS !== 'true' ||
+            configFiles.includes('package.json')) {
+            const patterns = buildPackageJsonPatterns(context.workspaceRoot, readJson);
+            isInPackageJsonWorkspaces = buildPackageJsonWorkspacesMatcher(patterns);
+        }
+        const isNextToProjectJson = (packageJsonPath) => {
+            return projectJsonRoots.has((0, node_path_1.dirname)(packageJsonPath));
+        };
+        const cache = (0, package_json_2.readPackageJsonConfigurationCache)();
+        return (0, plugins_1.createNodesFromFiles)((packageJsonPath, options, context) => {
+            const isInPackageManagerWorkspaces = isInPackageJsonWorkspaces(packageJsonPath);
+            if (!isInPackageManagerWorkspaces &&
+                !isNextToProjectJson(packageJsonPath)) {
+                // Skip if package.json is not part of the package.json workspaces and not next to a project.json.
+                return null;
+            }
+            return createNodeFromPackageJson(packageJsonPath, context.workspaceRoot, cache, isInPackageManagerWorkspaces);
+        }, packageJsons, _, context);
+    },
+];
+function splitConfigFiles(configFiles) {
+    const packageJsons = [];
+    const projectJsonRoots = new Set();
+    for (const configFile of configFiles) {
+        if ((0, path_2.basename)(configFile) === 'package.json') {
+            packageJsons.push(configFile);
+        }
+        else {
+            projectJsonRoots.add((0, node_path_1.dirname)(configFile));
+        }
+    }
+    return { packageJsons, projectJsonRoots };
+}
+function buildPackageJsonPatterns(workspaceRoot, readJson) {
+    const patterns = getGlobPatternsFromPackageManagerWorkspaces(workspaceRoot, readJson);
+    const negativePatterns = [];
+    const positivePatterns = [];
+    const positivePatternLookup = {};
+    const negativePatternLookup = {};
+    for (const pattern of patterns) {
+        if (pattern.startsWith('!')) {
+            negativePatterns.push(pattern);
+            negativePatternLookup[pattern.slice(1)] = true;
+        }
+        else {
+            positivePatterns.push(pattern);
+            positivePatternLookup[pattern] = true;
+        }
+    }
+    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 {
+        positive: positivePatterns,
+        positiveLookup: positivePatternLookup,
+        negative: negativePatterns,
+        negativeLookup: negativePatternLookup,
+    };
+}
+function buildPackageJsonWorkspacesMatcher(patterns) {
+    return (p) => 
+    // use lookup to avoid unnecessary minimatch calls
+    (patterns.positiveLookup[p] ||
+        patterns.positive.some((positive) => (0, minimatch_1.minimatch)(p, positive))) &&
+        /**
+         * minimatch will return true if the given p is NOT excluded by the negative pattern.
+         *
+         * For example if the negative pattern is "!packages/vite", then the given p "packages/vite" will return false,
+         * the given p "packages/something-else/package.json" will return true.
+         *
+         * Therefore, we need to ensure that every negative pattern returns true to validate that the given p is not
+         * excluded by any of the negative patterns.
+         */
+        !patterns.negativeLookup[p] &&
+        patterns.negative.every((negative) => (0, minimatch_1.minimatch)(p, negative));
+}
+function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackageManagerWorkspaces) {
+    const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, pkgJsonPath));
+    const projectRoot = (0, node_path_1.dirname)(pkgJsonPath);
+    const hash = (0, file_hasher_1.hashObject)({
+        ...json,
+        root: projectRoot,
+        isInPackageManagerWorkspaces,
+        nxVersion: versions_1.nxVersion,
+    });
+    const cached = cache[hash];
+    if (cached) {
+        return {
+            projects: {
+                [cached.root]: cached,
+            },
+        };
+    }
+    const project = buildProjectConfigurationFromPackageJson(json, workspaceRoot, pkgJsonPath, (0, nx_json_1.readNxJson)(workspaceRoot), isInPackageManagerWorkspaces);
+    cache[hash] = project;
+    return {
+        projects: {
+            [project.root]: project,
+        },
+    };
+}
+function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, packageJsonPath, nxJson, isInPackageManagerWorkspaces) {
+    const normalizedPath = packageJsonPath.split('\\').join('/');
+    const projectRoot = (0, node_path_1.dirname)(normalizedPath);
+    const siblingProjectJson = tryReadJson((0, node_path_1.join)(workspaceRoot, projectRoot, 'project.json'));
+    if (siblingProjectJson) {
+        for (const target of Object.keys(siblingProjectJson?.targets ?? {})) {
+            const { executor, command, options } = siblingProjectJson.targets[target];
+            if (
+            // will use run-commands, different target
+            command ||
+                // Either uses a different executor or runs a different script
+                (executor &&
+                    (executor !== 'nx:run-script' || options?.script !== target))) {
+                delete packageJson.scripts?.[target];
+            }
+        }
+    }
+    if (!packageJson.name && projectRoot === '.' && !packageJson.nx?.name) {
+        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, to_project_name_1.toProjectName)(normalizedPath);
+    const projectConfiguration = {
+        root: projectRoot,
+        name,
+        ...packageJson.nx,
+        targets: (0, package_json_1.readTargetsFromPackageJson)(packageJson, nxJson, projectRoot, workspaceRoot),
+        tags: (0, package_json_1.getTagsFromPackageJson)(packageJson),
+        metadata: (0, package_json_1.getMetadataFromPackageJson)(packageJson, isInPackageManagerWorkspaces),
+    };
+    if (nxJson?.workspaceLayout?.appsDir != nxJson?.workspaceLayout?.libsDir &&
+        nxJson?.workspaceLayout?.appsDir &&
+        projectRoot.startsWith(nxJson.workspaceLayout.appsDir)) {
+        projectConfiguration.projectType = 'application';
+    }
+    else if (typeof nxJson?.workspaceLayout?.libsDir !== 'undefined' &&
+        projectRoot.startsWith(nxJson.workspaceLayout.libsDir)) {
+        projectConfiguration.projectType = 'library';
+    }
+    return projectConfiguration;
+}
+/**
+ * Get the package.json globs from package manager workspaces
+ */
+function getGlobPatternsFromPackageManagerWorkspaces(root, 
+// allow overwriting these args so we can use them in devkit
+readJson = (path) => (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, path)), readYaml = (path) => (0, fileutils_1.readYamlFile)((0, node_path_1.join)(root, path)), exists = (p) => (0, node_fs_1.existsSync)((0, node_path_1.join)(root, p))) {
+    try {
+        const patterns = [];
+        const packageJson = readJson('package.json');
+        patterns.push(...normalizePatterns(Array.isArray(packageJson.workspaces)
+            ? packageJson.workspaces
+            : (packageJson.workspaces?.packages ?? [])));
+        if (exists('pnpm-workspace.yaml')) {
+            try {
+                const { packages } = readYaml('pnpm-workspace.yaml') ?? {};
+                patterns.push(...normalizePatterns(packages || []));
+            }
+            catch (e) {
+                output_1.output.warn({
+                    title: `${logger_1.NX_PREFIX} Unable to parse pnpm-workspace.yaml`,
+                    bodyLines: [e.toString()],
+                });
+            }
+        }
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(root, 'lerna.json'))) {
+            try {
+                const { packages } = readJson('lerna.json') ?? {};
+                patterns.push(...normalizePatterns(packages?.length > 0 ? packages : ['packages/*']));
+            }
+            catch (e) {
+                output_1.output.warn({
+                    title: `${logger_1.NX_PREFIX} Unable to parse lerna.json`,
+                    bodyLines: [e.toString()],
+                });
+            }
+        }
+        // Merge patterns from workspaces definitions
+        // TODO(@AgentEnder): update logic after better way to determine root project inclusion
+        // Include the root project
+        return packageJson.nx ? patterns.concat('package.json') : patterns;
+    }
+    catch {
+        return [];
+    }
+}
+function normalizePatterns(patterns) {
+    return patterns.map((pattern) => removeRelativePath(pattern.endsWith('/package.json')
+        ? pattern
+        : (0, path_1.joinPathFragments)(pattern, 'package.json')));
+}
+function removeRelativePath(pattern) {
+    return pattern.startsWith('./') ? pattern.substring(2) : pattern;
+}
+function tryReadJson(path) {
+    try {
+        return (0, fileutils_1.readJsonFile)(path);
+    }
+    catch {
+        return null;
+    }
+}

package/src/plugins/package-json/index.d.ts

@@ -0,0 +1,3 @@
+export * from './create-nodes';
+export declare const name = "nx/core/package-json";
+//# sourceMappingURL=index.d.ts.map

package/src/plugins/package-json/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/plugins/package-json/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,eAAO,MAAM,IAAI,yBAAyB,CAAC"}

package/src/plugins/package-json/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.name = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./create-nodes"), exports);
+exports.name = 'nx/core/package-json';

package/src/plugins/project-json/build-nodes/project-json.d.ts

@@ -0,0 +1,6 @@
+import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
+import { NxPluginV2 } from '../../../project-graph/plugins';
+export declare const ProjectJsonProjectsPlugin: NxPluginV2;
+export default ProjectJsonProjectsPlugin;
+export declare function buildProjectFromProjectJson(json: Partial<ProjectConfiguration>, path: string): ProjectConfiguration;
+//# sourceMappingURL=project-json.d.ts.map

package/src/plugins/project-json/build-nodes/project-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-json.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/plugins/project-json/build-nodes/project-json.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6CAA6C,CAAC;AAEnF,OAAO,EAEL,UAAU,EACX,MAAM,gCAAgC,CAAC;AAExC,eAAO,MAAM,yBAAyB,EAAE,UAyBvC,CAAC;AAEF,eAAe,yBAAyB,CAAC;AAEzC,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,OAAO,CAAC,oBAAoB,CAAC,EACnC,IAAI,EAAE,MAAM,GACX,oBAAoB,CAOtB"}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectJsonProjectsPlugin = void 0;
+exports.buildProjectFromProjectJson = buildProjectFromProjectJson;
+const node_path_1 = require("node:path");
+const fileutils_1 = require("../../../utils/fileutils");
+const plugins_1 = require("../../../project-graph/plugins");
+exports.ProjectJsonProjectsPlugin = {
+    name: 'nx/core/project-json',
+    createNodesV2: [
+        '{project.json,**/project.json}',
+        (configFiles, _, context) => {
+            return (0, plugins_1.createNodesFromFiles)((file) => {
+                const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(context.workspaceRoot, file));
+                const project = buildProjectFromProjectJson(json, file);
+                return {
+                    projects: {
+                        [project.root]: project,
+                    },
+                };
+            }, configFiles, _, context);
+        },
+    ],
+};
+exports.default = exports.ProjectJsonProjectsPlugin;
+function buildProjectFromProjectJson(json, path) {
+    const { name, root, ...rest } = json;
+    return {
+        name,
+        root: root ?? (0, node_path_1.dirname)(path),
+        ...rest,
+    };
+}

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

@@ -0,0 +1,12 @@
+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[]>;
+}
+//# sourceMappingURL=affected-project-graph-models.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"affected-project-graph-models.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/project-graph/affected/affected-project-graph-models.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EACL,YAAY,EACZ,uBAAuB,EACxB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,WAAW,2BAA2B;IAC1C,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;IAC3D,MAAM,EAAE,mBAAmB,CAAC,GAAG,CAAC,CAAC;IACjC,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAC9D,CACE,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,EAC5B,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC3D,MAAM,CAAC,EAAE,mBAAmB,CAAC,GAAG,CAAC,EACjC,WAAW,CAAC,EAAE,GAAG,EACjB,YAAY,CAAC,EAAE,YAAY,GAC1B,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CACjC"}

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,5 @@
+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>;
+//# sourceMappingURL=affected-project-graph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"affected-project-graph.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/project-graph/affected/affected-project-graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAmB,MAAM,eAAe,CAAC;AAU5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAK1D,wBAAsB,cAAc,CAClC,KAAK,EAAE,YAAY,EACnB,YAAY,EAAE,UAAU,EAAE,EAC1B,MAAM,GAAE,mBAAkC,EAC1C,WAAW,GAAE,GAAuB,GACnC,OAAO,CAAC,YAAY,CAAC,CAiCvB"}

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterAffected = filterAffected;
+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) {
+        performance.mark(locator.name + ':start');
+        const projects = await locator(touchedFiles, graph.nodes, nxJson, packageJson, graph);
+        performance.mark(locator.name + ':end');
+        performance.measure(locator.name, locator.name + ':start', locator.name + ':end');
+        touchedProjects.push(...projects);
+    }
+    return filterAffectedProjects(graph, {
+        projectGraphNodes: graph.nodes,
+        nxJson,
+        touchedProjects,
+    });
+}
+// -----------------------------------------------------------------------------
+function filterAffectedProjects(graph, ctx) {
+    const result = {
+        nodes: {},
+        externalNodes: {},
+        dependencies: {},
+    };
+    const reversed = (0, operators_1.reverse)(graph);
+    // Share visited Sets across all touched projects to avoid redundant traversal
+    // Previously, each touched project got its own Set, causing shared dependencies
+    // to be visited multiple times (O(touchedProjects × sharedDeps) → O(nodes))
+    const visitedNodes = new Set();
+    const visitedDeps = new Set();
+    for (const p of ctx.touchedProjects) {
+        addAffectedNodes(p, reversed, result, visitedNodes);
+    }
+    for (const p of ctx.touchedProjects) {
+        addAffectedDependencies(p, reversed, result, visitedDeps);
+    }
+    return result;
+}
+function addAffectedNodes(startingProject, reversed, result, visited) {
+    if (visited.has(startingProject))
+        return;
+    const reversedNode = reversed.nodes[startingProject];
+    const reversedExternalNode = reversed.externalNodes[startingProject];
+    if (!reversedNode && !reversedExternalNode) {
+        throw new Error(`Invalid project name is detected: "${startingProject}"`);
+    }
+    visited.add(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.has(startingProject))
+        return;
+    visited.add(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,3 @@
+import { TouchedProjectLocator } from '../affected-project-graph-models';
+export declare const getTouchedProjectsFromProjectGlobChanges: TouchedProjectLocator;
+//# sourceMappingURL=project-glob-changes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"project-glob-changes.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/affected/locators/project-glob-changes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AASzE,eAAO,MAAM,wCAAwC,EAAE,qBAmCpD,CAAC"}

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

@@ -0,0 +1,43 @@
+"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 path_1 = require("path");
+const fs_1 = require("fs");
+const retrieve_workspace_files_1 = require("../../utils/retrieve-workspace-files");
+const globs_1 = require("../../../utils/globs");
+const get_plugins_1 = require("../../plugins/get-plugins");
+const getTouchedProjectsFromProjectGlobChanges = async (touchedFiles, projectGraphNodes) => {
+    const globPattern = await (async () => {
+        // TODO: We need a quicker way to get patterns that should not
+        // require starting up plugin workers
+        if (process.env.NX_FORCE_REUSE_CACHED_GRAPH === 'true') {
+            return (0, globs_1.combineGlobPatterns)([
+                '**/package.json',
+                '**/project.json',
+                'project.json',
+                'package.json',
+            ]);
+        }
+        const plugins = (await (0, get_plugins_1.getPlugins)()).filter((p) => !!p.createNodes);
+        return (0, globs_1.combineGlobPatterns)((0, retrieve_workspace_files_1.getGlobPatternsOfPlugins)(plugins));
+    })();
+    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,5 @@
+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>;
+//# sourceMappingURL=workspace-json-changes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-json-changes.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/affected/locators/workspace-json-changes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAGL,UAAU,EACX,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAEzE,eAAO,MAAM,iCAAiC,EAAE,qBAAqB,CACnE,eAAe,GAAG,UAAU,CAkD7B,CAAC"}

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,4 @@
+import { TouchedProjectLocator } from '../affected-project-graph-models';
+export declare const getTouchedProjects: TouchedProjectLocator;
+export declare const getImplicitlyTouchedProjects: TouchedProjectLocator;
+//# sourceMappingURL=workspace-projects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-projects.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/affected/locators/workspace-projects.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAOzE,eAAO,MAAM,kBAAkB,EAAE,qBAahC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,qBA4C1C,CAAC"}

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = {
+        'nx.json': '*',
+    };
+    Object.values(projectGraphNodes || {}).forEach((node) => {
+        const namedInputs = {
+            ...nxJson.namedInputs,
+            ...node.data.namedInputs,
+        };
+        extractFilesFromTargetInputs(node.data.targets, namedInputs).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 extractFilesFromTargetInputs(targets, namedInputs) {
+    const globalFiles = [];
+    for (const target of Object.values(targets || {})) {
+        if (target.inputs) {
+            globalFiles.push(...extractFilesFromInputs(target.inputs, namedInputs));
+        }
+    }
+    return globalFiles;
+}
+function extractFilesFromInputs(inputs, namedInputs) {
+    const globalFiles = [];
+    for (const input of inputs) {
+        if (typeof input === 'string' && input in namedInputs) {
+            globalFiles.push(...extractFilesFromInputs(namedInputs[input], namedInputs));
+        }
+        else 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,24 @@
+import { FileData } from './file-utils';
+import { FileMapCache } from './nx-deps-cache';
+import type { LoadedNxPlugin } from './plugins/loaded-nx-plugin';
+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 hydrateFileMap(fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals): void;
+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 function applyProjectMetadata(graph: ProjectGraph, plugins: LoadedNxPlugin[], context: CreateMetadataContext, sourceMap: ConfigurationSourceMaps): Promise<{
+    graph: ProjectGraph;
+    errors?: CreateMetadataError[];
+}>;
+//# sourceMappingURL=build-project-graph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build-project-graph.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/project-graph/build-project-graph.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,EAIL,YAAY,EAEb,MAAM,iBAAiB,CAAC;AAGzB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAEL,qBAAqB,EAEtB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,OAAO,EACP,YAAY,EACZ,wBAAwB,EACzB,MAAM,yBAAyB,CAAC;AAIjC,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAI7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,EAEL,mBAAmB,EAKpB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,uBAAuB,EAExB,MAAM,qCAAqC,CAAC;AAQ7C,wBAAgB,UAAU,IAAI;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,QAAQ,EAAE,CAAC;IAC9B,cAAc,EAAE,yBAAyB,GAAG,IAAI,CAAC;CAClD,CAiBA;AAED,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,iBAAiB,EAAE,QAAQ,EAAE,EAC7B,cAAc,EAAE,yBAAyB,QAK1C;AAED,wBAAsB,oCAAoC,CACxD,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EACpD,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,EACvD,OAAO,EAAE,OAAO,EAChB,iBAAiB,EAAE,QAAQ,EAAE,EAC7B,cAAc,EAAE,yBAAyB,EACzC,YAAY,EAAE,YAAY,GAAG,IAAI,EACjC,OAAO,EAAE,cAAc,EAAE,EACzB,SAAS,EAAE,uBAAuB,GACjC,OAAO,CAAC;IACT,YAAY,EAAE,YAAY,CAAC;IAC3B,mBAAmB,EAAE,YAAY,CAAC;CACnC,CAAC,CA+FD;AA+OD,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,cAAc,EAAE,EACzB,OAAO,EAAE,qBAAqB,EAC9B,SAAS,EAAE,uBAAuB,GACjC,OAAO,CAAC;IAAE,KAAK,EAAE,YAAY,CAAC;IAAC,MAAM,CAAC,EAAE,mBAAmB,EAAE,CAAA;CAAE,CAAC,CAwFlE"}