@depup/nx 22.5.4-depup.0

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

@@ -0,0 +1,261 @@
+"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) {
+        packageJson.overrides = {
+            ...rootPackageJson.overrides,
+            ...packageJson.overrides,
+        };
+    }
+    // pnpm
+    if (rootPackageJson.pnpm?.overrides && !options.skipOverrides) {
+        packageJson.pnpm ??= {};
+        packageJson.pnpm.overrides = {
+            ...rootPackageJson.pnpm.overrides,
+            ...packageJson.pnpm.overrides,
+        };
+    }
+    // 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/src/plugins/js/project-graph/affected/lock-file-changes.d.ts

@@ -0,0 +1,6 @@
+import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+import { WholeFileChange } from '../../../../project-graph/file-utils';
+import { JsonChange } from '../../../../utils/json-diff';
+export declare const PNPM_LOCK_FILES: string[];
+export declare const getTouchedProjectsFromLockFile: TouchedProjectLocator<WholeFileChange | JsonChange>;
+//# sourceMappingURL=lock-file-changes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lock-file-changes.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/nx/src/plugins/js/project-graph/affected/lock-file-changes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,kEAAkE,CAAC;AACzG,OAAO,EAEL,eAAe,EAChB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAgB,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAKvE,eAAO,MAAM,eAAe,UAAsC,CAAC;AAUnE,eAAO,MAAM,8BAA8B,EAAE,qBAAqB,CAChE,eAAe,GAAG,UAAU,CA4B7B,CAAC"}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTouchedProjectsFromLockFile = exports.PNPM_LOCK_FILES = void 0;
+const configuration_1 = require("../../../../config/configuration");
+const json_diff_1 = require("../../../../utils/json-diff");
+const config_1 = require("../../utils/config");
+const find_matching_projects_1 = require("../../../../utils/find-matching-projects");
+exports.PNPM_LOCK_FILES = ['pnpm-lock.yaml', 'pnpm-lock.yml'];
+const ALL_LOCK_FILES = [
+    ...exports.PNPM_LOCK_FILES,
+    'package-lock.json',
+    'yarn.lock',
+    'bun.lockb',
+    'bun.lock',
+];
+const getTouchedProjectsFromLockFile = (fileChanges, projectGraphNodes) => {
+    const nxJson = (0, configuration_1.readNxJson)();
+    const { projectsAffectedByDependencyUpdates } = (0, config_1.jsPluginConfig)(nxJson);
+    const changedLockFile = fileChanges.find((f) => ALL_LOCK_FILES.includes(f.file));
+    if (projectsAffectedByDependencyUpdates === 'auto') {
+        const changedProjectPaths = getProjectPathsAffectedByDependencyUpdates(changedLockFile);
+        const changedProjectNames = getProjectsNamesFromPaths(projectGraphNodes, changedProjectPaths);
+        return changedProjectNames;
+    }
+    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;
+/**
+ * For pnpm projects, check lock file for changes to importers and return the project paths that have changes.
+ */
+const getProjectPathsAffectedByDependencyUpdates = (changedLockFile) => {
+    if (!changedLockFile) {
+        return [];
+    }
+    const changedProjectPaths = new Set();
+    if (exports.PNPM_LOCK_FILES.includes(changedLockFile.file)) {
+        for (const change of changedLockFile.getChanges()) {
+            if ((0, json_diff_1.isJsonChange)(change) &&
+                change.path[0] === 'importers' &&
+                change.path[1] !== undefined) {
+                changedProjectPaths.add(change.path[1]);
+            }
+        }
+    }
+    return Array.from(changedProjectPaths);
+};
+const getProjectsNamesFromPaths = (projectGraphNodes, projectPaths) => {
+    if (!projectPaths.length) {
+        return [];
+    }
+    const lookup = new RootPathLookup(projectGraphNodes);
+    return projectPaths
+        .map((path) => lookup.findNodeNameByRoot(path))
+        .filter(Boolean);
+};
+class RootPathLookup {
+    constructor(nodes) {
+        this.rootToNameMap = new Map();
+        Object.entries(nodes).forEach(([name, node]) => {
+            this.rootToNameMap.set(node.data.root, name);
+        });
+    }
+    findNodeNameByRoot(root) {
+        return this.rootToNameMap.get(root);
+    }
+}

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

@@ -0,0 +1,5 @@
+import { WholeFileChange } from '../../../../project-graph/file-utils';
+import { JsonChange } from '../../../../utils/json-diff';
+import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+export declare const getTouchedNpmPackages: TouchedProjectLocator<WholeFileChange | JsonChange>;
+//# sourceMappingURL=npm-packages.d.ts.map

package/src/plugins/js/project-graph/affected/npm-packages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"npm-packages.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/nx/src/plugins/js/project-graph/affected/npm-packages.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,eAAe,EAChB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAGL,UAAU,EACX,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,qBAAqB,EAAE,MAAM,kEAAkE,CAAC;AAQzG,eAAO,MAAM,qBAAqB,EAAE,qBAAqB,CACvD,eAAe,GAAG,UAAU,CAmG7B,CAAC"}

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

@@ -0,0 +1,93 @@
+"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);
+    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'))) {
+            // Changes to overrides, resolutions, or pnpm.overrides
+            // Find which package was changed and mark projects that depend on it as affected
+            const packageName = c.path[0] === 'pnpm' ? c.path[2] : c.path[1];
+            if (packageName) {
+                // Look for the npm package in external nodes
+                let npmPackage = npmPackages.find((pkg) => pkg.data.packageName === packageName);
+                if (npmPackage) {
+                    touched.push(npmPackage.name);
+                    // If it's a global package, all projects are affected
+                    if ('packageName' in npmPackage.data &&
+                        globalPackages.has(npmPackage.data.packageName)) {
+                        return Object.keys(projectGraph.nodes);
+                    }
+                }
+                else {
+                    // If the package isn't found in external nodes, it might affect all projects
+                    // since overrides can affect transitive dependencies
+                    return Object.keys(projectGraph.nodes);
+                }
+            }
+        }
+        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 touched;
+};
+exports.getTouchedNpmPackages = getTouchedNpmPackages;
+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/src/plugins/js/project-graph/affected/touched-projects.d.ts

@@ -0,0 +1,3 @@
+import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+export declare const getTouchedProjects: TouchedProjectLocator;
+//# sourceMappingURL=touched-projects.d.ts.map

package/src/plugins/js/project-graph/affected/touched-projects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"touched-projects.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/nx/src/plugins/js/project-graph/affected/touched-projects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,kEAAkE,CAAC;AAKzG,eAAO,MAAM,kBAAkB,EAAE,qBAoBhC,CAAC"}

package/src/plugins/js/project-graph/affected/touched-projects.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTouchedProjects = void 0;
+const lock_file_changes_1 = require("./lock-file-changes");
+const npm_packages_1 = require("./npm-packages");
+const tsconfig_json_changes_1 = require("./tsconfig-json-changes");
+const getTouchedProjects = (touchedFiles, nodes, nxJson, packageJson, graph) => {
+    const touchedProjects = new Set();
+    [
+        lock_file_changes_1.getTouchedProjectsFromLockFile,
+        npm_packages_1.getTouchedNpmPackages,
+        tsconfig_json_changes_1.getTouchedProjectsFromTsConfig,
+    ].forEach((fn) => {
+        fn(touchedFiles, nodes, nxJson, packageJson, graph).forEach((p) => touchedProjects.add(p));
+    });
+    return Array.from(touchedProjects);
+};
+exports.getTouchedProjects = getTouchedProjects;

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

@@ -0,0 +1,5 @@
+import { WholeFileChange } from '../../../../project-graph/file-utils';
+import { JsonChange } from '../../../../utils/json-diff';
+import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+export declare const getTouchedProjectsFromTsConfig: TouchedProjectLocator<WholeFileChange | JsonChange>;
+//# sourceMappingURL=tsconfig-json-changes.d.ts.map

package/src/plugins/js/project-graph/affected/tsconfig-json-changes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsconfig-json-changes.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/nx/src/plugins/js/project-graph/affected/tsconfig-json-changes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AACvE,OAAO,EAGL,UAAU,EACX,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,qBAAqB,EAAE,MAAM,kEAAkE,CAAC;AAGzG,eAAO,MAAM,8BAA8B,EAAE,qBAAqB,CAChE,eAAe,GAAG,UAAU,CAoC7B,CAAC"}

package/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'));
+}

package/src/plugins/js/project-graph/build-dependencies/build-dependencies.d.ts

@@ -0,0 +1,7 @@
+import { CreateDependenciesContext } from '../../../../project-graph/plugins';
+import { RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
+export declare function buildExplicitDependencies(jsPluginConfig: {
+    analyzeSourceFiles?: boolean;
+    analyzePackageJson?: boolean;
+}, ctx: CreateDependenciesContext): RawProjectGraphDependency[];
+//# sourceMappingURL=build-dependencies.d.ts.map

package/src/plugins/js/project-graph/build-dependencies/build-dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-dependencies.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/nx/src/plugins/js/project-graph/build-dependencies/build-dependencies.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAE,yBAAyB,EAAE,MAAM,iDAAiD,CAAC;AAK5F,wBAAgB,yBAAyB,CACvC,cAAc,EAAE;IACd,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,EACD,GAAG,EAAE,yBAAyB,GAC7B,yBAAyB,EAAE,CA8C7B"}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExplicitDependencies = buildExplicitDependencies;
+const explicit_package_json_dependencies_1 = require("./explicit-package-json-dependencies");
+const explicit_project_dependencies_1 = require("./explicit-project-dependencies");
+const target_project_locator_1 = require("./target-project-locator");
+function buildExplicitDependencies(jsPluginConfig, ctx) {
+    if (totalNumberOfFilesToProcess(ctx) === 0)
+        return [];
+    let dependencies = [];
+    // TODO: TargetProjectLocator is a public API, so we can't change the shape of it
+    // We should eventually let it accept Record<string, ProjectConfiguration> s.t. we
+    // don't have to reshape the CreateDependenciesContext here.
+    const nodes = {};
+    Object.keys(ctx.projects).forEach((key) => {
+        nodes[key] = {
+            name: key,
+            type: null,
+            data: ctx.projects[key],
+        };
+    });
+    const targetProjectLocator = new target_project_locator_1.TargetProjectLocator(nodes, ctx.externalNodes);
+    if (jsPluginConfig.analyzeSourceFiles === undefined ||
+        jsPluginConfig.analyzeSourceFiles === true) {
+        let tsExists = false;
+        try {
+            require.resolve('typescript');
+            tsExists = true;
+        }
+        catch { }
+        if (tsExists) {
+            dependencies = dependencies.concat((0, explicit_project_dependencies_1.buildExplicitTypeScriptDependencies)(ctx, targetProjectLocator));
+        }
+    }
+    if (jsPluginConfig.analyzePackageJson === undefined ||
+        jsPluginConfig.analyzePackageJson === true) {
+        dependencies = dependencies.concat((0, explicit_package_json_dependencies_1.buildExplicitPackageJsonDependencies)(ctx, targetProjectLocator));
+    }
+    return dependencies;
+}
+function totalNumberOfFilesToProcess(ctx) {
+    let totalNumOfFilesToProcess = 0;
+    Object.values(ctx.filesToProcess.projectFileMap).forEach((t) => (totalNumOfFilesToProcess += t.length));
+    return totalNumOfFilesToProcess;
+}

package/src/plugins/js/project-graph/build-dependencies/explicit-package-json-dependencies.d.ts

@@ -0,0 +1,5 @@
+import type { CreateDependenciesContext } from '../../../../project-graph/plugins';
+import { type RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
+import { TargetProjectLocator } from './target-project-locator';
+export declare function buildExplicitPackageJsonDependencies(ctx: CreateDependenciesContext, targetProjectLocator: TargetProjectLocator): RawProjectGraphDependency[];
+//# sourceMappingURL=explicit-package-json-dependencies.d.ts.map

package/src/plugins/js/project-graph/build-dependencies/explicit-package-json-dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explicit-package-json-dependencies.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/nx/src/plugins/js/project-graph/build-dependencies/explicit-package-json-dependencies.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AACnF,OAAO,EACL,KAAK,yBAAyB,EAE/B,MAAM,iDAAiD,CAAC;AAGzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAEhE,wBAAgB,oCAAoC,CAClD,GAAG,EAAE,yBAAyB,EAC9B,oBAAoB,EAAE,oBAAoB,GACzC,yBAAyB,EAAE,CAe7B"}