nx 20.8.4 → 22.7.7

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

@@ -1,247 +0,0 @@
-"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 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 rootPackageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(options.root ?? workspace_root_1.workspaceRoot, '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)(options.root ?? workspace_root_1.workspaceRoot, 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) => {
-        return (packageJson[section][packageName] ||
-            (isLibrary && rootPackageJson[section]?.[packageName]) ||
-            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);
-    return npmDeps;
-}
-function findAllNpmDeps(projectFileMap, projectNode, graph, npmDeps, seen, ignoredDependencies, dependencyPatterns, rootPatterns) {
-    if (seen.has(projectNode.name))
-        return;
-    seen.add(projectNode.name);
-    const projectFiles = (0, task_hasher_1.filterUsingGlobPatterns)(projectNode.data.root, projectFileMap[projectNode.name] || [], 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);
-            }
-        }
-    }
-}
-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

@@ -1,4 +0,0 @@
-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 getTouchedProjectsFromLockFile: TouchedProjectLocator<WholeFileChange | JsonChange>;

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

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTouchedProjectsFromLockFile = void 0;
-const configuration_1 = require("../../../../config/configuration");
-const config_1 = require("../../utils/config");
-const find_matching_projects_1 = require("../../../../utils/find-matching-projects");
-const getTouchedProjectsFromLockFile = (fileChanges, projectGraphNodes) => {
-    const nxJson = (0, configuration_1.readNxJson)();
-    const { projectsAffectedByDependencyUpdates } = (0, config_1.jsPluginConfig)(nxJson);
-    if (projectsAffectedByDependencyUpdates === 'auto') {
-        return [];
-    }
-    else if (Array.isArray(projectsAffectedByDependencyUpdates)) {
-        return (0, find_matching_projects_1.findMatchingProjects)(projectsAffectedByDependencyUpdates, projectGraphNodes);
-    }
-    const lockFiles = [
-        'package-lock.json',
-        'yarn.lock',
-        'pnpm-lock.yaml',
-        'pnpm-lock.yml',
-        'bun.lockb',
-        'bun.lock',
-    ];
-    if (fileChanges.some((f) => lockFiles.includes(f.file))) {
-        return Object.values(projectGraphNodes).map((p) => p.name);
-    }
-    return [];
-};
-exports.getTouchedProjectsFromLockFile = getTouchedProjectsFromLockFile;

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

@@ -1,68 +0,0 @@
-"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, 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/build-dependencies/build-dependencies.js

@@ -1,45 +0,0 @@
-"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.fromEntries(Object.entries(ctx.projects).map(([key, config]) => [
-        key,
-        {
-            name: key,
-            type: null,
-            data: config,
-        },
-    ]));
-    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.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildExplicitPackageJsonDependencies = buildExplicitPackageJsonDependencies;
-const project_graph_1 = require("../../../../config/project-graph");
-const file_utils_1 = require("../../../../project-graph/file-utils");
-const project_graph_builder_1 = require("../../../../project-graph/project-graph-builder");
-const json_1 = require("../../../../utils/json");
-const path_1 = require("../../../../utils/path");
-function buildExplicitPackageJsonDependencies(ctx, targetProjectLocator) {
-    const res = [];
-    const nodes = Object.values(ctx.projects);
-    Object.keys(ctx.filesToProcess.projectFileMap).forEach((source) => {
-        Object.values(ctx.filesToProcess.projectFileMap[source]).forEach((f) => {
-            if (isPackageJsonAtProjectRoot(nodes, f.file)) {
-                processPackageJson(source, f.file, ctx, targetProjectLocator, res);
-            }
-        });
-    });
-    return res;
-}
-function isPackageJsonAtProjectRoot(nodes, fileName) {
-    return (fileName.endsWith('package.json') &&
-        nodes.find((projectNode) => (0, path_1.joinPathFragments)(projectNode.root, 'package.json') === fileName));
-}
-function processPackageJson(sourceProject, fileName, ctx, targetProjectLocator, collectedDeps) {
-    try {
-        const deps = readDeps((0, json_1.parseJson)((0, file_utils_1.defaultFileRead)(fileName)));
-        for (const d of Object.keys(deps)) {
-            const localProject = targetProjectLocator.findDependencyInWorkspaceProjects(d);
-            if (localProject) {
-                // package.json refers to another project in the monorepo
-                const dependency = {
-                    source: sourceProject,
-                    target: localProject,
-                    sourceFile: fileName,
-                    type: project_graph_1.DependencyType.static,
-                };
-                (0, project_graph_builder_1.validateDependency)(dependency, ctx);
-                collectedDeps.push(dependency);
-                continue;
-            }
-            const externalNodeName = targetProjectLocator.findNpmProjectFromImport(d, fileName);
-            if (!externalNodeName) {
-                continue;
-            }
-            const dependency = {
-                source: sourceProject,
-                target: externalNodeName,
-                sourceFile: fileName,
-                type: project_graph_1.DependencyType.static,
-            };
-            (0, project_graph_builder_1.validateDependency)(dependency, ctx);
-            collectedDeps.push(dependency);
-        }
-    }
-    catch (e) {
-        if (process.env.NX_VERBOSE_LOGGING === 'true') {
-            console.error(e);
-        }
-    }
-}
-function readDeps(packageJson) {
-    const deps = {};
-    /**
-     * We process dependencies in a rough order of increasing importance such that if a dependency is listed in multiple
-     * sections, the version listed under the "most important" one wins, with production dependencies being the most important.
-     */
-    const depType = [
-        'optionalDependencies',
-        'peerDependencies',
-        'devDependencies',
-        'dependencies',
-    ];
-    for (const type of depType) {
-        for (const [depName, depVersion] of Object.entries(packageJson[type] || {})) {
-            deps[depName] = depVersion;
-        }
-    }
-    return deps;
-}

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

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildExplicitTypeScriptDependencies = buildExplicitTypeScriptDependencies;
-const path_1 = require("path");
-const project_graph_1 = require("../../../../config/project-graph");
-const project_graph_builder_1 = require("../../../../project-graph/project-graph-builder");
-const path_2 = require("../../../../utils/path");
-const workspace_root_1 = require("../../../../utils/workspace-root");
-function isRoot(projects, projectName) {
-    return projects[projectName]?.root === '.';
-}
-function convertImportToDependency(importExpr, sourceFile, source, type, targetProjectLocator) {
-    const target = targetProjectLocator.findProjectFromImport(importExpr, sourceFile);
-    if (!target) {
-        return;
-    }
-    return {
-        source,
-        target,
-        sourceFile,
-        type,
-    };
-}
-function buildExplicitTypeScriptDependencies(ctx, targetProjectLocator) {
-    const res = [];
-    const filesToProcess = {};
-    const moduleExtensions = [
-        '.ts',
-        '.js',
-        '.tsx',
-        '.jsx',
-        '.mts',
-        '.mjs',
-        '.cjs',
-        '.cts',
-    ];
-    // TODO: This can be removed when vue is stable
-    if (isVuePluginInstalled()) {
-        moduleExtensions.push('.vue');
-    }
-    for (const [project, fileData] of Object.entries(ctx.filesToProcess.projectFileMap)) {
-        filesToProcess[project] ??= [];
-        for (const { file } of fileData) {
-            if (moduleExtensions.some((ext) => file.endsWith(ext))) {
-                filesToProcess[project].push((0, path_1.join)(workspace_root_1.workspaceRoot, file));
-            }
-        }
-    }
-    const { findImports } = require('../../../../native');
-    const imports = findImports(filesToProcess);
-    for (const { sourceProject, file, staticImportExpressions, dynamicImportExpressions, } of imports) {
-        const normalizedFilePath = (0, path_2.normalizePath)((0, path_1.relative)(workspace_root_1.workspaceRoot, file));
-        for (const importExpr of staticImportExpressions) {
-            const dependency = convertImportToDependency(importExpr, normalizedFilePath, sourceProject, project_graph_1.DependencyType.static, targetProjectLocator);
-            if (!dependency) {
-                continue;
-            }
-            // TODO: These edges technically should be allowed but we need to figure out how to separate config files out from root
-            if (isRoot(ctx.projects, dependency.source) ||
-                !isRoot(ctx.projects, dependency.target)) {
-                res.push(dependency);
-            }
-        }
-        for (const importExpr of dynamicImportExpressions) {
-            const dependency = convertImportToDependency(importExpr, normalizedFilePath, sourceProject, project_graph_1.DependencyType.dynamic, targetProjectLocator);
-            if (!dependency) {
-                continue;
-            }
-            // TODO: These edges technically should be allowed but we need to figure out how to separate config files out from root
-            if (isRoot(ctx.projects, dependency.source) ||
-                !isRoot(ctx.projects, dependency.target)) {
-                (0, project_graph_builder_1.validateDependency)(dependency, ctx);
-                res.push(dependency);
-            }
-        }
-    }
-    return res;
-}
-function isVuePluginInstalled() {
-    try {
-        // nx-ignore-next-line
-        require.resolve('@nx/vue');
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

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

@@ -1,71 +0,0 @@
-import type { ProjectGraphExternalNode, ProjectGraphProjectNode } from '../../../../config/project-graph';
-/**
- * The key is a combination of the package name and the workspace relative directory
- * containing the file importing it e.g. `lodash__packages/my-lib`, the value is the
- * resolved external node name from the project graph.
- */
-type NpmResolutionCache = Map<string, string | null>;
-type PathPattern = {
-    pattern: string;
-    prefix: string;
-    suffix: string;
-};
-export declare function isBuiltinModuleImport(importExpr: string): boolean;
-export declare class TargetProjectLocator {
-    private readonly nodes;
-    private readonly externalNodes;
-    private readonly npmResolutionCache;
-    private projectRootMappings;
-    private npmProjects;
-    private tsConfig;
-    private paths;
-    private parsedPathPatterns;
-    private typescriptResolutionCache;
-    private packagesMetadata;
-    constructor(nodes: Record<string, ProjectGraphProjectNode>, externalNodes?: Record<string, ProjectGraphExternalNode>, npmResolutionCache?: NpmResolutionCache);
-    /**
-     * Resolve any workspace or external project that matches the given import expression,
-     * originating from the given filePath.
-     *
-     * @param importExpr
-     * @param filePath
-     */
-    findProjectFromImport(importExpr: string, filePath: string): string;
-    /**
-     * Resolve any external project that matches the given import expression,
-     * relative to the given file path.
-     *
-     * @param importExpr
-     * @param projectRoot
-     */
-    findNpmProjectFromImport(importExpr: string, fromFilePath: string): string | null;
-    /**
-     * Return file paths matching the import relative to the repo root
-     * @param normalizedImportExpr
-     * @deprecated Use `findMatchingPaths` instead. It will be removed in Nx v22.
-     */
-    findPaths(normalizedImportExpr: string): string[] | undefined;
-    findMatchingPaths(importExpr: string): [pattern: string | PathPattern, paths: string[]] | undefined;
-    findImportInWorkspaceProjects(importPath: string): string | null;
-    findDependencyInWorkspaceProjects(dep: string): string | null;
-    private isPatternMatch;
-    private parsePaths;
-    private resolveImportWithTypescript;
-    private resolveImportWithRequire;
-    private findProjectOfResolvedModule;
-    private getAbsolutePath;
-    private getRootTsConfig;
-    private findMatchingProjectFiles;
-    /**
-     * In many cases the package.json will be directly resolvable, so we try that first.
-     * If, however, package exports are used and the package.json is not defined, we will
-     * need to resolve the main entry point of the package and traverse upwards to find the
-     * package.json.
-     *
-     * In some cases, such as when multiple module formats are published, the resolved package.json
-     * might only contain the "type" field - no "name" or "version", so in such cases we keep traversing
-     * until we find a package.json that contains the "name" and "version" fields.
-     */
-    private readPackageJson;
-}
-export {};