@ohos-ports/nx 19.8.4-beta.0 → 23.2.0-beta.1

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

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPackageJson = createPackageJson;
+exports.findProjectsNpmDependencies = findProjectsNpmDependencies;
+const fileutils_1 = require("../../../utils/fileutils");
+const object_sort_1 = require("../../../utils/object-sort");
+const project_graph_1 = require("../../../config/project-graph");
+const package_json_1 = require("../../../utils/package-json");
+const fs_1 = require("fs");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const configuration_1 = require("../../../config/configuration");
+const nx_deps_cache_1 = require("../../../project-graph/nx-deps-cache");
+const path_1 = require("path");
+const task_hasher_1 = require("../../../hasher/task-hasher");
+const output_1 = require("../../../utils/output");
+/**
+ * Creates a package.json in the output directory for support to install dependencies within containers.
+ *
+ * If a package.json exists in the project, it will reuse that.
+ * If isProduction flag is set, it wil  remove devDependencies and optional peerDependencies
+ */
+function createPackageJson(projectName, graph, options = {}, fileMap = null) {
+    const projectNode = graph.nodes[projectName];
+    const isLibrary = projectNode.type === 'lib';
+    const root = options.root ?? workspace_root_1.workspaceRoot;
+    const rootPackageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, 'package.json'));
+    const npmDeps = findProjectsNpmDependencies(projectNode, graph, options.target, rootPackageJson, {
+        helperDependencies: options.helperDependencies,
+        isProduction: options.isProduction,
+    }, fileMap);
+    // default package.json if one does not exist
+    let packageJson = {
+        name: projectName,
+        version: '0.0.1',
+    };
+    const projectPackageJsonPath = (0, path_1.join)(root, projectNode.data.root, 'package.json');
+    if ((0, fs_1.existsSync)(projectPackageJsonPath)) {
+        try {
+            packageJson = (0, fileutils_1.readJsonFile)(projectPackageJsonPath);
+            // for standalone projects we don't want to include all the root dependencies
+            if (graph.nodes[projectName].data.root === '.') {
+                // TODO: We should probably think more on this - Nx can't always
+                // detect all external dependencies, and there's not a way currently
+                // to tell Nx that we need one of these deps. For non-standalone projects
+                // we tell people to add it to the package.json of the project, and we
+                // merge it. For standalone, this pattern doesn't work because of this piece of code.
+                // It breaks expectations, but also, I don't know another way around it currently.
+                // If Nx doesn't pick up a dep, say some css lib that is only imported in a .scss file,
+                // we need to be able to tell it to keep that dep in the generated package.json.
+                delete packageJson.dependencies;
+                delete packageJson.devDependencies;
+            }
+            if (options.isProduction) {
+                delete packageJson.devDependencies;
+            }
+        }
+        catch (e) { }
+    }
+    const getVersion = (packageName, version, section) => {
+        // Try project package.json first (single section)
+        const projectVersion = (0, package_json_1.getDependencyVersionFromPackageJson)(packageName, root, packageJson, [section]);
+        if (projectVersion) {
+            return projectVersion;
+        }
+        // For libraries, fall back to root package.json (single section)
+        if (isLibrary) {
+            const rootVersion = (0, package_json_1.getDependencyVersionFromPackageJson)(packageName, root, rootPackageJson, [section]);
+            if (rootVersion) {
+                return rootVersion;
+            }
+        }
+        return version;
+    };
+    Object.entries(npmDeps.dependencies).forEach(([packageName, version]) => {
+        if (rootPackageJson.devDependencies?.[packageName] &&
+            !packageJson.dependencies?.[packageName] &&
+            !packageJson.peerDependencies?.[packageName]) {
+            // don't store dev dependencies for production
+            if (!options.isProduction) {
+                packageJson.devDependencies ??= {};
+                packageJson.devDependencies[packageName] = getVersion(packageName, version, 'devDependencies');
+            }
+        }
+        else {
+            if (!packageJson.peerDependencies?.[packageName]) {
+                packageJson.dependencies ??= {};
+                packageJson.dependencies[packageName] = getVersion(packageName, version, 'dependencies');
+            }
+        }
+    });
+    if (!isLibrary) {
+        Object.entries(npmDeps.peerDependencies).forEach(([packageName, version]) => {
+            if (!packageJson.peerDependencies?.[packageName]) {
+                if (rootPackageJson.dependencies?.[packageName]) {
+                    packageJson.dependencies ??= {};
+                    packageJson.dependencies[packageName] = getVersion(packageName, version, 'dependencies');
+                    return;
+                }
+                const isOptionalPeer = npmDeps.peerDependenciesMeta[packageName]?.optional;
+                if (!isOptionalPeer) {
+                    if (!options.isProduction ||
+                        rootPackageJson.dependencies?.[packageName]) {
+                        packageJson.peerDependencies ??= {};
+                        packageJson.peerDependencies[packageName] = getVersion(packageName, version, 'dependencies');
+                    }
+                }
+                else if (!options.isProduction) {
+                    // add peer optional dependencies if not in production
+                    packageJson.peerDependencies ??= {};
+                    packageJson.peerDependencies[packageName] = version;
+                    packageJson.peerDependenciesMeta ??= {};
+                    packageJson.peerDependenciesMeta[packageName] = {
+                        optional: true,
+                    };
+                }
+            }
+        });
+    }
+    packageJson.devDependencies &&= (0, object_sort_1.sortObjectByKeys)(packageJson.devDependencies);
+    packageJson.dependencies &&= (0, object_sort_1.sortObjectByKeys)(packageJson.dependencies);
+    packageJson.peerDependencies &&= (0, object_sort_1.sortObjectByKeys)(packageJson.peerDependencies);
+    packageJson.peerDependenciesMeta &&= (0, object_sort_1.sortObjectByKeys)(packageJson.peerDependenciesMeta);
+    if (rootPackageJson.packageManager && !options.skipPackageManager) {
+        if (packageJson.packageManager &&
+            packageJson.packageManager !== rootPackageJson.packageManager) {
+            output_1.output.warn({
+                title: 'Package Manager Mismatch',
+                bodyLines: [
+                    `The project ${projectName} has explicitly specified "packageManager" config of "${packageJson.packageManager}" but the workspace is using "${rootPackageJson.packageManager}".`,
+                    `Please remove the project level "packageManager" config or align it with the workspace root package.json.`,
+                ],
+            });
+        }
+        packageJson.packageManager = rootPackageJson.packageManager;
+    }
+    // region Overrides/Resolutions
+    // npm
+    if (rootPackageJson.overrides && !options.skipOverrides) {
+        // npm throws EOVERRIDE when an override key is also a direct dependency
+        // (unless specs match). The pruned dist pins exact versions and already
+        // resolved everything via the lockfile, so drop those redundant overrides.
+        const mergedOverrides = {
+            ...rootPackageJson.overrides,
+            ...packageJson.overrides,
+        };
+        const overrides = {};
+        let hasOverrides = false;
+        for (const name in mergedOverrides) {
+            if (packageJson.dependencies?.[name] ||
+                packageJson.devDependencies?.[name] ||
+                packageJson.peerDependencies?.[name] ||
+                packageJson.optionalDependencies?.[name]) {
+                continue;
+            }
+            overrides[name] = mergedOverrides[name];
+            hasOverrides = true;
+        }
+        if (hasOverrides) {
+            packageJson.overrides = overrides;
+        }
+        else {
+            delete packageJson.overrides;
+        }
+    }
+    // pnpm
+    if (rootPackageJson.pnpm?.overrides && !options.skipOverrides) {
+        packageJson.pnpm ??= {};
+        packageJson.pnpm.overrides = {
+            ...rootPackageJson.pnpm.overrides,
+            ...packageJson.pnpm.overrides,
+        };
+    }
+    // pnpm install configuration
+    const rootPnpm = rootPackageJson.pnpm;
+    if (rootPnpm) {
+        // string[] fields — copy from root
+        for (const field of [
+            'onlyBuiltDependencies',
+            'neverBuiltDependencies',
+            'ignoredOptionalDependencies',
+        ]) {
+            if (rootPnpm[field]) {
+                packageJson.pnpm ??= {};
+                packageJson.pnpm[field] = rootPnpm[field];
+            }
+        }
+        // object fields — merge with project-level overrides
+        if (rootPnpm.allowBuilds) {
+            packageJson.pnpm ??= {};
+            packageJson.pnpm.allowBuilds = {
+                ...rootPnpm.allowBuilds,
+                ...packageJson.pnpm.allowBuilds,
+            };
+        }
+        if (rootPnpm.supportedArchitectures) {
+            packageJson.pnpm ??= {};
+            packageJson.pnpm.supportedArchitectures = {
+                ...rootPnpm.supportedArchitectures,
+                ...packageJson.pnpm.supportedArchitectures,
+            };
+        }
+    }
+    // yarn
+    if (rootPackageJson.resolutions && !options.skipOverrides) {
+        packageJson.resolutions = {
+            ...rootPackageJson.resolutions,
+            ...packageJson.resolutions,
+        };
+    }
+    // endregion Overrides/Resolutions
+    return packageJson;
+}
+function findProjectsNpmDependencies(projectNode, graph, target, rootPackageJson, options, fileMap) {
+    if (fileMap == null) {
+        fileMap = (0, nx_deps_cache_1.readFileMapCache)()?.fileMap?.projectFileMap || {};
+    }
+    const { selfInputs, dependencyInputs } = target
+        ? (0, task_hasher_1.getTargetInputs)((0, configuration_1.readNxJson)(), projectNode, target)
+        : { selfInputs: [], dependencyInputs: [] };
+    const npmDeps = {
+        dependencies: {},
+        peerDependencies: {},
+        peerDependenciesMeta: {},
+    };
+    const seen = new Set();
+    options.helperDependencies?.forEach((dep) => {
+        seen.add(dep);
+        npmDeps.dependencies[graph.externalNodes[dep].data.packageName] =
+            graph.externalNodes[dep].data.version;
+        recursivelyCollectPeerDependencies(dep, graph, npmDeps, seen);
+    });
+    // if it's production, we want to ignore all found devDependencies
+    const ignoredDependencies = options.isProduction && rootPackageJson.devDependencies
+        ? [
+            ...(options.ignoredDependencies || []),
+            ...Object.keys(rootPackageJson.devDependencies),
+        ]
+        : options.ignoredDependencies || [];
+    findAllNpmDeps(fileMap, projectNode, graph, npmDeps, seen, ignoredDependencies, dependencyInputs, selfInputs, false);
+    return npmDeps;
+}
+function findAllNpmDeps(projectFileMap, projectNode, graph, npmDeps, seen, ignoredDependencies, dependencyPatterns, rootPatterns, isTransitiveDependency = false) {
+    if (seen.has(projectNode.name))
+        return;
+    seen.add(projectNode.name);
+    const projectFiles = (0, task_hasher_1.filterUsingGlobPatterns)(projectNode.data.root, projectFileMap[projectNode.name] || [], isTransitiveDependency
+        ? ['{projectRoot}/**/*']
+        : (rootPatterns ?? dependencyPatterns));
+    const projectDependencies = new Set();
+    projectFiles.forEach((fileData) => fileData.deps?.forEach((dep) => projectDependencies.add((0, project_graph_1.fileDataDepTarget)(dep))));
+    for (const dep of projectDependencies) {
+        const node = graph.externalNodes[dep];
+        if (seen.has(dep)) {
+            // if it's in peerDependencies, move it to regular dependencies
+            // since this is a direct dependency of the project
+            if (node && npmDeps.peerDependencies[node.data.packageName]) {
+                npmDeps.dependencies[node.data.packageName] = node.data.version;
+                delete npmDeps.peerDependencies[node.data.packageName];
+            }
+        }
+        else {
+            if (node) {
+                seen.add(dep);
+                // do not add ignored dependencies to the list or non-npm dependencies
+                if (ignoredDependencies.includes(node.data.packageName) ||
+                    node.type !== 'npm') {
+                    continue;
+                }
+                npmDeps.dependencies[node.data.packageName] = node.data.version;
+                recursivelyCollectPeerDependencies(node.name, graph, npmDeps, seen);
+            }
+            else if (graph.nodes[dep]) {
+                findAllNpmDeps(projectFileMap, graph.nodes[dep], graph, npmDeps, seen, ignoredDependencies, dependencyPatterns, undefined, true);
+            }
+        }
+    }
+}
+function recursivelyCollectPeerDependencies(projectName, graph, npmDeps, seen) {
+    const npmPackage = graph.externalNodes[projectName];
+    if (!npmPackage) {
+        return npmDeps;
+    }
+    const packageName = npmPackage.data.packageName;
+    try {
+        const packageJson = require(`${packageName}/package.json`);
+        if (!packageJson.peerDependencies) {
+            return npmDeps;
+        }
+        Object.keys(packageJson.peerDependencies)
+            .map((dependencyName) => `npm:${dependencyName}`)
+            .map((dependency) => graph.externalNodes[dependency])
+            .filter(Boolean)
+            .forEach((node) => {
+            if (!seen.has(node.name)) {
+                seen.add(node.name);
+                npmDeps.peerDependencies[node.data.packageName] = node.data.version;
+                if (packageJson.peerDependenciesMeta &&
+                    packageJson.peerDependenciesMeta[node.data.packageName] &&
+                    packageJson.peerDependenciesMeta[node.data.packageName].optional) {
+                    npmDeps.peerDependenciesMeta[node.data.packageName] = {
+                        optional: true,
+                    };
+                }
+                recursivelyCollectPeerDependencies(node.name, graph, npmDeps, seen);
+            }
+        });
+        return npmDeps;
+    }
+    catch (e) {
+        return npmDeps;
+    }
+}

package/dist/src/plugins/js/project-graph/affected/lock-file-changes.d.ts

@@ -0,0 +1,3 @@
+import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+import { LockFileChange, WholeFileChange } from '../../../../project-graph/file-utils';
+export declare const getTouchedProjectsFromLockFile: TouchedProjectLocator<WholeFileChange | LockFileChange>;

package/dist/src/plugins/js/project-graph/affected/lock-file-changes.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTouchedProjectsFromLockFile = void 0;
+const file_utils_1 = require("../../../../project-graph/file-utils");
+const config_1 = require("../../utils/config");
+const find_matching_projects_1 = require("../../../../utils/find-matching-projects");
+const file_hasher_1 = require("../../../../hasher/file-hasher");
+const output_1 = require("../../../../utils/output");
+const lock_file_1 = require("../../lock-file/lock-file");
+const getTouchedProjectsFromLockFile = (fileChanges, projectGraphNodes, nxJson, packageJson, projectGraph) => {
+    const { projectsAffectedByDependencyUpdates } = (0, config_1.jsPluginConfig)(nxJson);
+    const changedLockFile = fileChanges.find((f) => lock_file_1.AUTO_AFFECTED_LOCK_FILES.includes(f.file));
+    if (projectsAffectedByDependencyUpdates === 'auto') {
+        return getAutoAffected(changedLockFile, projectGraphNodes, projectGraph, packageJson);
+    }
+    else if (Array.isArray(projectsAffectedByDependencyUpdates)) {
+        return (0, find_matching_projects_1.findMatchingProjects)(projectsAffectedByDependencyUpdates, projectGraphNodes);
+    }
+    if (changedLockFile) {
+        return Object.values(projectGraphNodes).map((p) => p.name);
+    }
+    return [];
+};
+exports.getTouchedProjectsFromLockFile = getTouchedProjectsFromLockFile;
+/**
+ * In auto mode, parse the lock file at the base and head revisions
+ * using Nx's existing lock file parsers, then diff the resulting
+ * external-node maps to determine which packages actually changed.
+ *
+ * Returns external node names (e.g. "npm:lodash@4.17.21") so the
+ * graph reversal in filterAffected can walk back to workspace projects.
+ */
+function getAutoAffected(changedLockFile, projectGraphNodes, projectGraph, packageJson) {
+    const allProjectNames = Object.values(projectGraphNodes).map((p) => p.name);
+    if (!changedLockFile) {
+        return [];
+    }
+    const changes = changedLockFile.getChanges();
+    // A WholeFileChange means we were unable to read both revisions of
+    // the lock file (e.g. missing base revision, git error). Fall back
+    // to marking all projects affected.
+    if (!changes.every(file_utils_1.isLockFileChange)) {
+        return allProjectNames;
+    }
+    const changedPackageNames = getChangedPackageNames(changedLockFile.file, changes, packageJson);
+    if (changedPackageNames === null) {
+        return allProjectNames;
+    }
+    if (changedPackageNames.size === 0) {
+        return [];
+    }
+    // Look up the changed packages in the project graph's external nodes
+    // and return the external node names. The graph reversal in
+    // filterAffected walks from these nodes to workspace projects.
+    const { touchedNodeNames, missingPackageNames } = findExternalNodesByPackageName(changedPackageNames, projectGraph.externalNodes ?? {});
+    if (missingPackageNames.size > 0) {
+        return allProjectNames;
+    }
+    return touchedNodeNames;
+}
+/**
+ * Parse the base and head revisions of the lock file with Nx's
+ * existing parsers and diff the resulting package -> version maps.
+ *
+ * Returns the set of changed package names, or null if parsing
+ * failed (in which case the caller should fall back to all projects).
+ */
+function getChangedPackageNames(file, changes, packageJson) {
+    try {
+        const changed = new Set();
+        // calculateFileChanges emits a single LockFileChange per lock file, but
+        // the iteration keeps the contract open in case multiple ranges are ever
+        // emitted for the same file.
+        for (const change of changes) {
+            const baseFingerprints = collectPackageFingerprints((0, lock_file_1.getLockFileNodesForName)(file, change.baseContent, (0, file_hasher_1.hashArray)([change.baseContent]), packageJson).nodes);
+            const headFingerprints = collectPackageFingerprints((0, lock_file_1.getLockFileNodesForName)(file, change.headContent, (0, file_hasher_1.hashArray)([change.headContent]), packageJson).nodes);
+            for (const [name, fingerprints] of headFingerprints) {
+                const baseSet = baseFingerprints.get(name);
+                if (!baseSet || !setsEqual(baseSet, fingerprints)) {
+                    changed.add(name);
+                }
+            }
+            for (const name of baseFingerprints.keys()) {
+                if (!headFingerprints.has(name)) {
+                    changed.add(name);
+                }
+            }
+        }
+        return changed;
+    }
+    catch (e) {
+        output_1.output.warn({
+            title: `Failed to parse "${file}" for projectsAffectedByDependencyUpdates "auto" mode. All projects will be marked as affected.`,
+            bodyLines: [e instanceof Error ? e.message : String(e)],
+        });
+        return null;
+    }
+}
+/**
+ * Build a map of packageName -> set of versions present in the
+ * external-node record returned by a lock-file parser. We include both
+ * version and hash so patched/tarball/integrity-only changes still
+ * count as lockfile changes even when the semver stays the same.
+ */
+function collectPackageFingerprints(nodes) {
+    const fingerprints = new Map();
+    for (const node of Object.values(nodes ?? {})) {
+        const name = node.data?.packageName;
+        if (!name)
+            continue;
+        const fingerprint = JSON.stringify({
+            version: node.data.version ?? '',
+            hash: node.data.hash ?? '',
+        });
+        let set = fingerprints.get(name);
+        if (!set) {
+            set = new Set();
+            fingerprints.set(name, set);
+        }
+        set.add(fingerprint);
+    }
+    return fingerprints;
+}
+function setsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const value of a) {
+        if (!b.has(value))
+            return false;
+    }
+    return true;
+}
+/**
+ * Given a set of package names, find all matching external node names
+ * in the project graph.
+ */
+function findExternalNodesByPackageName(packageNames, externalNodes) {
+    const touchedNodeNames = [];
+    const matchedPackageNames = new Set();
+    for (const [name, node] of Object.entries(externalNodes)) {
+        if (packageNames.has(node.data.packageName)) {
+            touchedNodeNames.push(name);
+            matchedPackageNames.add(node.data.packageName);
+        }
+    }
+    return {
+        touchedNodeNames,
+        missingPackageNames: new Set(Array.from(packageNames).filter((name) => !matchedPackageNames.has(name))),
+    };
+}

package/dist/src/plugins/js/project-graph/affected/npm-packages.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTouchedNpmPackages = void 0;
+const file_utils_1 = require("../../../../project-graph/file-utils");
+const json_diff_1 = require("../../../../utils/json-diff");
+const logger_1 = require("../../../../utils/logger");
+const get_package_name_from_import_path_1 = require("../../../../utils/get-package-name-from-import-path");
+const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGraph) => {
+    const packageJsonChange = touchedFiles.find((f) => f.file === 'package.json');
+    if (!packageJsonChange)
+        return [];
+    const globalPackages = new Set(getGlobalPackages(nxJson.plugins));
+    let touched = [];
+    const changes = packageJsonChange.getChanges();
+    const npmPackages = Object.values(projectGraph.externalNodes);
+    let packagesByName;
+    const missingTouchedNpmPackages = [];
+    for (const c of changes) {
+        if ((0, json_diff_1.isJsonChange)(c) &&
+            (c.path[0] === 'dependencies' || c.path[0] === 'devDependencies') &&
+            c.path.length === 2) {
+            // A package was deleted so mark all workspace projects as touched.
+            if (c.type === json_diff_1.JsonDiffType.Deleted) {
+                touched = Object.keys(projectGraph.nodes);
+                break;
+            }
+            else {
+                let npmPackage = npmPackages.find((pkg) => pkg.data.packageName === c.path[1]);
+                if (!npmPackage) {
+                    // dependency can also point to a workspace project
+                    const nodes = Object.values(projectGraph.nodes);
+                    npmPackage = nodes.find((n) => n.name === c.path[1]);
+                }
+                if (!npmPackage) {
+                    missingTouchedNpmPackages.push(c.path[1]);
+                    continue;
+                }
+                touched.push(npmPackage.name);
+                // If it was a type declarations package then also mark its corresponding implementation package as affected
+                if (npmPackage.name.startsWith('npm:@types/')) {
+                    const implementationNpmPackage = npmPackages.find((pkg) => pkg.data.packageName === c.path[1].substring(7));
+                    if (implementationNpmPackage) {
+                        touched.push(implementationNpmPackage.name);
+                    }
+                }
+                if ('packageName' in npmPackage.data) {
+                    if (globalPackages.has(npmPackage.data.packageName)) {
+                        return Object.keys(projectGraph.nodes);
+                    }
+                }
+            }
+        }
+        else if ((0, json_diff_1.isJsonChange)(c) &&
+            (c.path[0] === 'overrides' ||
+                c.path[0] === 'resolutions' ||
+                (c.path[0] === 'pnpm' && c.path[1] === 'overrides'))) {
+            const packageSelector = getPackageSelector(c);
+            if (!packageSelector)
+                continue;
+            packagesByName ??= groupPackagesByName(npmPackages);
+            const matchingNpmPackages = findPackagesForSelector(packageSelector, packagesByName, c.path[0] === 'pnpm');
+            // An unresolved selector can still target a transitive dependency,
+            // so fall back to marking every project affected.
+            if (!matchingNpmPackages.length) {
+                return Object.keys(projectGraph.nodes);
+            }
+            if (matchingNpmPackages.some((pkg) => globalPackages.has(pkg.data.packageName))) {
+                return Object.keys(projectGraph.nodes);
+            }
+            touched.push(...matchingNpmPackages.map((pkg) => pkg.name));
+        }
+        else if ((0, file_utils_1.isWholeFileChange)(c)) {
+            // Whole file was touched, so all npm packages are touched.
+            touched = npmPackages.map((pkg) => pkg.name);
+            break;
+        }
+    }
+    if (missingTouchedNpmPackages.length) {
+        logger_1.logger.warn(`The affected projects might have not been identified properly. The package(s) ${missingTouchedNpmPackages.join(', ')} were not found. Please open an issue in GitHub including the package.json file.`);
+    }
+    return [...new Set(touched)];
+};
+exports.getTouchedNpmPackages = getTouchedNpmPackages;
+function getPackageSelector(change) {
+    if (typeof change.value.lhs !== 'string' &&
+        typeof change.value.rhs !== 'string') {
+        return;
+    }
+    const selectorIndex = change.path[0] === 'pnpm' ? 2 : change.path.length - 1;
+    const selector = change.path[selectorIndex];
+    return selector === '.' ? change.path[selectorIndex - 1] : selector;
+}
+function groupPackagesByName(npmPackages) {
+    const packagesByName = new Map();
+    for (const pkg of npmPackages) {
+        const packageName = pkg.data.packageName;
+        if (!packageName)
+            continue;
+        const packages = packagesByName.get(packageName);
+        if (packages) {
+            packages.push(pkg);
+        }
+        else {
+            packagesByName.set(packageName, [pkg]);
+        }
+    }
+    return packagesByName;
+}
+function findPackagesForSelector(selector, packagesByName, isPnpmOverride) {
+    if (isPnpmOverride) {
+        // Pnpm does not treat `>` as a parent delimiter when it starts a range.
+        const parentDelimiterIndex = selector.search(/[^ |@]>/);
+        if (parentDelimiterIndex !== -1) {
+            selector = selector.slice(parentDelimiterIndex + 2);
+        }
+    }
+    const packageName = selector.match(/(?:^|\/)(@[^/@>\s]+\/[^/@>\s]+|[^/@>\s]+)(?:@[^/]*)?$/)?.[1];
+    return packageName ? (packagesByName.get(packageName) ?? []) : [];
+}
+function getGlobalPackages(plugins) {
+    return (plugins ?? [])
+        .map((p) => (0, get_package_name_from_import_path_1.getPackageNameFromImportPath)(typeof p === 'string' ? p : p.plugin))
+        .concat('nx');
+}

package/dist/src/plugins/js/project-graph/affected/tsconfig-json-changes.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTouchedProjectsFromTsConfig = void 0;
+const json_diff_1 = require("../../../../utils/json-diff");
+const typescript_1 = require("../../utils/typescript");
+const getTouchedProjectsFromTsConfig = (touchedFiles, _a, _b, _c, graph) => {
+    const rootTsConfig = (0, typescript_1.getRootTsConfigFileName)();
+    if (!rootTsConfig) {
+        return [];
+    }
+    const tsConfigJsonChanges = touchedFiles.find((change) => change.file === rootTsConfig);
+    if (!tsConfigJsonChanges) {
+        return [];
+    }
+    const changes = tsConfigJsonChanges.getChanges();
+    if (!allChangesArePathChanges(changes)) {
+        return Object.keys(graph.nodes);
+    }
+    const touched = [];
+    for (let i = 0; i < changes.length; i++) {
+        const change = changes[i];
+        if (change.path.length !== 4) {
+            continue;
+        }
+        // If a path is deleted, everything is touched
+        if (change.type === json_diff_1.JsonDiffType.Deleted) {
+            return Object.keys(graph.nodes);
+        }
+        touched.push(...getProjectsAffectedByPaths(change, Object.values(graph.nodes)));
+    }
+    return touched;
+};
+exports.getTouchedProjectsFromTsConfig = getTouchedProjectsFromTsConfig;
+function allChangesArePathChanges(changes) {
+    return changes.every(isChangeToPathMappings);
+}
+/**
+ * Gets both previous project and current project of a particular change to tsconfig paths
+ */
+function getProjectsAffectedByPaths(change, nodes) {
+    const result = [];
+    const paths = [change.value.lhs, change.value.rhs];
+    paths.forEach((path) => {
+        nodes.forEach((project) => {
+            const normalizedPath = path && path.startsWith('./') ? path.substring(2) : path;
+            const r = project.data.root;
+            const root = r && r.endsWith('/') ? r.substring(0, r.length - 1) : r;
+            if ((normalizedPath && root && normalizedPath.startsWith(`${root}/`)) ||
+                normalizedPath == root) {
+                result.push(project.name);
+            }
+        });
+    });
+    return result;
+}
+/**
+ * Change is possibly a change to path mappings
+ */
+function isChangeToPathMappings(change) {
+    return ((0, json_diff_1.isJsonChange)(change) &&
+        change.path[0] === 'compilerOptions' &&
+        (!change.path[1] || change.path[1] === 'paths'));
+}