@ohos-ports/nx 17.3.2-beta.0

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTouchedProjectsFromLockFile = void 0;
+const getTouchedProjectsFromLockFile = (fileChanges, projectGraphNodes) => {
+    const lockFiles = [
+        'package-lock.json',
+        'yarn.lock',
+        'pnpm-lock.yaml',
+        'pnpm-lock.yml',
+    ];
+    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.d.ts

@@ -0,0 +1,4 @@
+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>;

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

@@ -0,0 +1,56 @@
+"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 getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGraph) => {
+    const packageJsonChange = touchedFiles.find((f) => f.file === 'package.json');
+    if (!packageJsonChange)
+        return [];
+    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);
+                    }
+                }
+            }
+        }
+        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;

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

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

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,4 @@
+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>;

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,6 @@
+import { CreateDependenciesContext } from '../../../../utils/nx-plugin';
+import { RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
+export declare function buildExplicitDependencies(jsPluginConfig: {
+    analyzeSourceFiles?: boolean;
+    analyzePackageJson?: boolean;
+}, ctx: CreateDependenciesContext): RawProjectGraphDependency[];

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExplicitDependencies = void 0;
+const explicit_project_dependencies_1 = require("./explicit-project-dependencies");
+const explicit_package_json_dependencies_1 = require("./explicit-package-json-dependencies");
+function buildExplicitDependencies(jsPluginConfig, ctx) {
+    if (totalNumberOfFilesToProcess(ctx) === 0)
+        return [];
+    let dependencies = [];
+    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));
+        }
+    }
+    if (jsPluginConfig.analyzePackageJson === undefined ||
+        jsPluginConfig.analyzePackageJson === true) {
+        dependencies = dependencies.concat((0, explicit_package_json_dependencies_1.buildExplicitPackageJsonDependencies)(ctx));
+    }
+    return dependencies;
+}
+exports.buildExplicitDependencies = buildExplicitDependencies;
+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,3 @@
+import { CreateDependenciesContext } from '../../../../utils/nx-plugin';
+import { RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
+export declare function buildExplicitPackageJsonDependencies(ctx: CreateDependenciesContext): RawProjectGraphDependency[];

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExplicitPackageJsonDependencies = void 0;
+const file_utils_1 = require("../../../../project-graph/file-utils");
+const path_1 = require("path");
+const project_graph_1 = require("../../../../config/project-graph");
+const json_1 = require("../../../../utils/json");
+const path_2 = require("../../../../utils/path");
+const project_graph_builder_1 = require("../../../../project-graph/project-graph-builder");
+function buildExplicitPackageJsonDependencies(ctx) {
+    const res = [];
+    let packageNameMap = undefined;
+    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)) {
+                // we only create the package name map once and only if a package.json file changes
+                packageNameMap = packageNameMap || createPackageNameMap(ctx.projects);
+                processPackageJson(source, f.file, ctx, res, packageNameMap);
+            }
+        });
+    });
+    return res;
+}
+exports.buildExplicitPackageJsonDependencies = buildExplicitPackageJsonDependencies;
+function createPackageNameMap(projects) {
+    const res = {};
+    for (let projectName of Object.keys(projects)) {
+        try {
+            const packageJson = (0, json_1.parseJson)((0, file_utils_1.defaultFileRead)((0, path_1.join)(projects[projectName].root, 'package.json')));
+            res[packageJson.name ?? projectName] = projectName;
+        }
+        catch (e) { }
+    }
+    return res;
+}
+function isPackageJsonAtProjectRoot(nodes, fileName) {
+    return (fileName.endsWith('package.json') &&
+        nodes.find((projectNode) => (0, path_2.joinPathFragments)(projectNode.root, 'package.json') === fileName));
+}
+function processPackageJson(sourceProject, fileName, ctx, collectedDeps, packageNameMap) {
+    try {
+        const deps = readDeps((0, json_1.parseJson)((0, file_utils_1.defaultFileRead)(fileName)));
+        // the name matches the import path
+        deps.forEach((d) => {
+            // package.json refers to another project in the monorepo
+            if (packageNameMap[d]) {
+                const dependency = {
+                    source: sourceProject,
+                    target: packageNameMap[d],
+                    sourceFile: fileName,
+                    type: project_graph_1.DependencyType.static,
+                };
+                (0, project_graph_builder_1.validateDependency)(dependency, ctx);
+                collectedDeps.push(dependency);
+            }
+            else if (ctx.externalNodes[`npm:${d}`]) {
+                const dependency = {
+                    source: sourceProject,
+                    target: `npm:${d}`,
+                    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.log(e);
+        }
+    }
+}
+function readDeps(packageJson) {
+    return [
+        ...Object.keys(packageJson?.dependencies ?? {}),
+        ...Object.keys(packageJson?.devDependencies ?? {}),
+        ...Object.keys(packageJson?.peerDependencies ?? {}),
+        ...Object.keys(packageJson?.optionalDependencies ?? {}),
+    ];
+}

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

@@ -0,0 +1,3 @@
+import { CreateDependenciesContext } from '../../../../utils/nx-plugin';
+import { RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
+export declare function buildExplicitTypeScriptDependencies(ctx: CreateDependenciesContext): RawProjectGraphDependency[];

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExplicitTypeScriptDependencies = void 0;
+const target_project_locator_1 = require("./target-project-locator");
+const project_graph_1 = require("../../../../config/project-graph");
+const path_1 = require("path");
+const workspace_root_1 = require("../../../../utils/workspace-root");
+const path_2 = require("../../../../utils/path");
+const project_graph_builder_1 = require("../../../../project-graph/project-graph-builder");
+function isRoot(projects, projectName) {
+    return projects[projectName]?.root === '.';
+}
+function convertImportToDependency(importExpr, sourceFile, source, type, targetProjectLocator) {
+    const target = targetProjectLocator.findProjectWithImport(importExpr, sourceFile) ??
+        `npm:${importExpr}`;
+    return {
+        source,
+        target,
+        sourceFile,
+        type,
+    };
+}
+function buildExplicitTypeScriptDependencies(ctx) {
+    // 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);
+    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.fileMap.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);
+            // 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);
+            // 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;
+}
+exports.buildExplicitTypeScriptDependencies = buildExplicitTypeScriptDependencies;
+function isVuePluginInstalled() {
+    try {
+        // nx-ignore-next-line
+        require.resolve('@nx/vue');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { Scanner } from 'typescript';
+/**
+ * @deprecated This is deprecated and will be removed in Nx 19.
+ * This was not intended to be exposed.
+ * Please talk to us if you need this.
+ */
+export declare function stripSourceCode(scanner: Scanner, contents: string): string;

package/src/plugins/js/project-graph/build-dependencies/strip-source-code.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripSourceCode = void 0;
+let SyntaxKind;
+/**
+ * @deprecated This is deprecated and will be removed in Nx 19.
+ * This was not intended to be exposed.
+ * Please talk to us if you need this.
+ */
+function stripSourceCode(scanner, contents) {
+    if (!SyntaxKind) {
+        SyntaxKind = require('typescript').SyntaxKind;
+    }
+    if (contents.indexOf('loadChildren') > -1) {
+        return contents;
+    }
+    scanner.setText(contents);
+    let token = scanner.scan();
+    let lastNonTriviaToken = SyntaxKind.Unknown;
+    const statements = [];
+    const templateStack = [];
+    let ignoringLine = false;
+    let braceDepth = 0;
+    let start = null;
+    while (token !== SyntaxKind.EndOfFileToken) {
+        const currentToken = token;
+        const potentialStart = scanner.getStartPos();
+        switch (token) {
+            case SyntaxKind.MultiLineCommentTrivia:
+            case SyntaxKind.SingleLineCommentTrivia: {
+                const isMultiLineCommentTrivia = token === SyntaxKind.MultiLineCommentTrivia;
+                const start = potentialStart + 2;
+                token = scanner.scan();
+                const end = scanner.getStartPos() - (isMultiLineCommentTrivia ? 2 : 0);
+                const comment = contents.substring(start, end).trim();
+                if (comment === 'nx-ignore-next-line') {
+                    // reading till the end of the line
+                    while (token === SyntaxKind.WhitespaceTrivia ||
+                        token === SyntaxKind.NewLineTrivia) {
+                        token = scanner.scan();
+                    }
+                    ignoringLine = true;
+                }
+                break;
+            }
+            case SyntaxKind.NewLineTrivia: {
+                ignoringLine = false;
+                token = scanner.scan();
+                break;
+            }
+            case SyntaxKind.RequireKeyword:
+            case SyntaxKind.ImportKeyword: {
+                token = scanner.scan();
+                if (ignoringLine) {
+                    break;
+                }
+                while (token === SyntaxKind.WhitespaceTrivia ||
+                    token === SyntaxKind.NewLineTrivia) {
+                    token = scanner.scan();
+                }
+                start = potentialStart;
+                break;
+            }
+            case SyntaxKind.TemplateHead: {
+                templateStack.push(braceDepth);
+                braceDepth = 0;
+                token = scanner.scan();
+                break;
+            }
+            case SyntaxKind.SlashToken: {
+                if (shouldRescanSlashToken(lastNonTriviaToken)) {
+                    token = scanner.reScanSlashToken();
+                }
+                token = scanner.scan();
+                break;
+            }
+            case SyntaxKind.OpenBraceToken: {
+                ++braceDepth;
+                token = scanner.scan();
+                break;
+            }
+            case SyntaxKind.CloseBraceToken: {
+                if (braceDepth) {
+                    --braceDepth;
+                }
+                else if (templateStack.length) {
+                    token = scanner.reScanTemplateToken(false);
+                    if (token === SyntaxKind.LastTemplateToken) {
+                        braceDepth = templateStack.pop();
+                    }
+                }
+                token = scanner.scan();
+                break;
+            }
+            case SyntaxKind.ExportKeyword: {
+                token = scanner.scan();
+                if (ignoringLine) {
+                    break;
+                }
+                while (token === SyntaxKind.WhitespaceTrivia ||
+                    token === SyntaxKind.NewLineTrivia) {
+                    token = scanner.scan();
+                }
+                if (token === SyntaxKind.OpenBraceToken ||
+                    token === SyntaxKind.AsteriskToken ||
+                    token === SyntaxKind.TypeKeyword) {
+                    start = potentialStart;
+                }
+                break;
+            }
+            case SyntaxKind.StringLiteral: {
+                if (start !== null) {
+                    token = scanner.scan();
+                    if (token === SyntaxKind.CloseParenToken) {
+                        token = scanner.scan();
+                    }
+                    const end = scanner.getStartPos();
+                    statements.push(contents.substring(start, end));
+                    start = null;
+                }
+                else {
+                    token = scanner.scan();
+                }
+                break;
+            }
+            default: {
+                token = scanner.scan();
+            }
+        }
+        if (currentToken > SyntaxKind.LastTriviaToken) {
+            lastNonTriviaToken = currentToken;
+        }
+    }
+    return statements.join('\n');
+}
+exports.stripSourceCode = stripSourceCode;
+function shouldRescanSlashToken(lastNonTriviaToken) {
+    switch (lastNonTriviaToken) {
+        case SyntaxKind.Identifier:
+        case SyntaxKind.StringLiteral:
+        case SyntaxKind.NumericLiteral:
+        case SyntaxKind.BigIntLiteral:
+        case SyntaxKind.RegularExpressionLiteral:
+        case SyntaxKind.ThisKeyword:
+        case SyntaxKind.PlusPlusToken:
+        case SyntaxKind.MinusMinusToken:
+        case SyntaxKind.CloseParenToken:
+        case SyntaxKind.CloseBracketToken:
+        case SyntaxKind.CloseBraceToken:
+        case SyntaxKind.TrueKeyword:
+        case SyntaxKind.FalseKeyword:
+            return false;
+        default:
+            return true;
+    }
+}

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

@@ -0,0 +1,32 @@
+import { ProjectGraphExternalNode, ProjectGraphProjectNode } from '../../../../config/project-graph';
+export declare class TargetProjectLocator {
+    private readonly nodes;
+    private readonly externalNodes;
+    private projectRootMappings;
+    private npmProjects;
+    private tsConfig;
+    private paths;
+    private typescriptResolutionCache;
+    private npmResolutionCache;
+    constructor(nodes: Record<string, ProjectGraphProjectNode>, externalNodes: Record<string, ProjectGraphExternalNode>);
+    /**
+     * Find a project based on its import
+     *
+     * @param importExpr
+     * @param filePath
+     */
+    findProjectWithImport(importExpr: string, filePath: string): string;
+    /**
+     * Return file paths matching the import relative to the repo root
+     * @param normalizedImportExpr
+     * @returns
+     */
+    findPaths(normalizedImportExpr: string): string[] | undefined;
+    private resolveImportWithTypescript;
+    private resolveImportWithRequire;
+    private findNpmPackage;
+    private findProjectOfResolvedModule;
+    private getAbsolutePath;
+    private getRootTsConfig;
+    private findMatchingProjectFiles;
+}