@ohos-ports/nx 17.3.2-beta.0

package/src/project-graph/file-map-utils.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateFileMap = exports.createFileMap = exports.createFileMapUsingProjectGraph = exports.createProjectFileMapUsingProjectGraph = void 0;
+const client_1 = require("../daemon/client/client");
+const workspace_context_1 = require("../utils/workspace-context");
+const workspace_root_1 = require("../utils/workspace-root");
+const project_graph_1 = require("./project-graph");
+const build_all_workspace_files_1 = require("./utils/build-all-workspace-files");
+const find_project_for_path_1 = require("./utils/find-project-for-path");
+async function createProjectFileMapUsingProjectGraph(graph) {
+    return (await createFileMapUsingProjectGraph(graph)).fileMap.projectFileMap;
+}
+exports.createProjectFileMapUsingProjectGraph = createProjectFileMapUsingProjectGraph;
+// TODO: refactor this to pull straight from the rust context instead of creating the file map in JS
+async function createFileMapUsingProjectGraph(graph) {
+    const configs = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(graph);
+    let files;
+    if (client_1.daemonClient.enabled()) {
+        files = await client_1.daemonClient.getAllFileData();
+    }
+    else {
+        files = (0, workspace_context_1.getAllFileDataInContext)(workspace_root_1.workspaceRoot);
+    }
+    return createFileMap(configs, files);
+}
+exports.createFileMapUsingProjectGraph = createFileMapUsingProjectGraph;
+function createFileMap(projectsConfigurations, allWorkspaceFiles) {
+    const projectFileMap = {};
+    const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projectsConfigurations.projects);
+    const nonProjectFiles = [];
+    for (const projectName of Object.keys(projectsConfigurations.projects)) {
+        projectFileMap[projectName] ??= [];
+    }
+    for (const f of allWorkspaceFiles) {
+        const projectFileMapKey = (0, find_project_for_path_1.findProjectForPath)(f.file, projectRootMappings);
+        if (projectFileMapKey) {
+            const matchingProjectFiles = projectFileMap[projectFileMapKey];
+            if (matchingProjectFiles) {
+                matchingProjectFiles.push(f);
+            }
+        }
+        else {
+            nonProjectFiles.push(f);
+        }
+    }
+    return {
+        allWorkspaceFiles,
+        fileMap: {
+            projectFileMap,
+            nonProjectFiles,
+        },
+    };
+}
+exports.createFileMap = createFileMap;
+function updateFileMap(projectsConfigurations, rustReferences, updatedFiles, deletedFiles) {
+    const updates = (0, workspace_context_1.updateProjectFiles)(Object.fromEntries((0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projectsConfigurations)), rustReferences, updatedFiles, deletedFiles);
+    return {
+        fileMap: updates.fileMap,
+        allWorkspaceFiles: (0, build_all_workspace_files_1.buildAllWorkspaceFiles)(updates.fileMap.projectFileMap, updates.fileMap.nonProjectFiles),
+        rustReferences: updates.externalReferences,
+    };
+}
+exports.updateFileMap = updateFileMap;

package/src/project-graph/file-utils.d.ts

@@ -0,0 +1,31 @@
+import { FileData } from '../config/project-graph';
+import { ProjectsConfigurations } from '../config/workspace-json-project-json';
+import type { NxArgs } from '../utils/command-line-utils';
+export interface Change {
+    type: string;
+}
+export interface FileChange<T extends Change = Change> extends FileData {
+    getChanges: () => T[];
+}
+export declare class WholeFileChange implements Change {
+    type: string;
+}
+export declare class DeletedFileChange implements Change {
+    type: string;
+}
+export declare function isWholeFileChange(change: Change): change is WholeFileChange;
+export declare function isDeletedFileChange(change: Change): change is DeletedFileChange;
+export declare function calculateFileChanges(files: string[], allWorkspaceFiles: FileData[], nxArgs?: NxArgs, readFileAtRevision?: (f: string, r: void | string) => string, ignore?: any): FileChange[];
+export declare const TEN_MEGABYTES: number;
+/**
+ * TODO(v19): Remove this function
+ * @deprecated To get projects use {@link retrieveProjectConfigurations} instead
+ */
+export declare function readWorkspaceConfig(opts: {
+    format: 'angularCli' | 'nx';
+    path?: string;
+}): ProjectsConfigurations;
+export declare function defaultFileRead(filePath: string): string | null;
+export declare function readPackageJson(): any;
+export { FileData };
+export { readNxJson, workspaceLayout } from '../config/configuration';

package/src/project-graph/file-utils.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceLayout = exports.readNxJson = exports.readPackageJson = exports.defaultFileRead = exports.readWorkspaceConfig = exports.TEN_MEGABYTES = exports.calculateFileChanges = exports.isDeletedFileChange = exports.isWholeFileChange = exports.DeletedFileChange = exports.WholeFileChange = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const configuration_1 = require("../config/configuration");
+const workspace_root_1 = require("../utils/workspace-root");
+const fileutils_1 = require("../utils/fileutils");
+const json_diff_1 = require("../utils/json-diff");
+const project_graph_1 = require("./project-graph");
+const angular_json_1 = require("../adapter/angular-json");
+const ignore_1 = require("../utils/ignore");
+const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
+const project_configuration_utils_1 = require("./utils/project-configuration-utils");
+const nx_plugin_deprecated_1 = require("../utils/nx-plugin.deprecated");
+const minimatch_1 = require("minimatch");
+const package_json_next_to_project_json_1 = require("../plugins/project-json/build-nodes/package-json-next-to-project-json");
+class WholeFileChange {
+    constructor() {
+        this.type = 'WholeFileChange';
+    }
+}
+exports.WholeFileChange = WholeFileChange;
+class DeletedFileChange {
+    constructor() {
+        this.type = 'WholeFileDeleted';
+    }
+}
+exports.DeletedFileChange = DeletedFileChange;
+function isWholeFileChange(change) {
+    return change.type === 'WholeFileChange';
+}
+exports.isWholeFileChange = isWholeFileChange;
+function isDeletedFileChange(change) {
+    return change.type === 'WholeFileDeleted';
+}
+exports.isDeletedFileChange = isDeletedFileChange;
+function calculateFileChanges(files, allWorkspaceFiles, nxArgs, readFileAtRevision = defaultReadFileAtRevision, ignore = (0, ignore_1.getIgnoreObject)()) {
+    files = files.filter((f) => !ignore.ignores(f));
+    return files.map((f) => {
+        const ext = (0, path_1.extname)(f);
+        const file = allWorkspaceFiles.find((fileData) => fileData.file == f);
+        const hash = file?.hash;
+        return {
+            file: f,
+            ext,
+            hash,
+            getChanges: () => {
+                if (!(0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, f))) {
+                    return [new DeletedFileChange()];
+                }
+                if (!nxArgs) {
+                    return [new WholeFileChange()];
+                }
+                if (nxArgs.files && nxArgs.files.includes(f)) {
+                    return [new WholeFileChange()];
+                }
+                switch (ext) {
+                    case '.json':
+                        try {
+                            const atBase = readFileAtRevision(f, nxArgs.base);
+                            const atHead = readFileAtRevision(f, nxArgs.head);
+                            return (0, json_diff_1.jsonDiff)(JSON.parse(atBase), JSON.parse(atHead));
+                        }
+                        catch (e) {
+                            return [new WholeFileChange()];
+                        }
+                    default:
+                        return [new WholeFileChange()];
+                }
+            },
+        };
+    });
+}
+exports.calculateFileChanges = calculateFileChanges;
+exports.TEN_MEGABYTES = 1024 * 10000;
+function defaultReadFileAtRevision(file, revision) {
+    try {
+        const fileFullPath = `${workspace_root_1.workspaceRoot}${path_1.sep}${file}`;
+        const gitRepositoryPath = (0, child_process_1.execSync)('git rev-parse --show-toplevel')
+            .toString()
+            .trim();
+        const filePathInGitRepository = (0, path_1.relative)(gitRepositoryPath, fileFullPath)
+            .split(path_1.sep)
+            .join('/');
+        return !revision
+            ? (0, fs_1.readFileSync)(file, 'utf-8')
+            : (0, child_process_1.execSync)(`git show ${revision}:${filePathInGitRepository}`, {
+                maxBuffer: exports.TEN_MEGABYTES,
+                stdio: ['pipe', 'pipe', 'ignore'],
+            })
+                .toString()
+                .trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * TODO(v19): Remove this function
+ * @deprecated To get projects use {@link retrieveProjectConfigurations} instead
+ */
+function readWorkspaceConfig(opts) {
+    let configuration = null;
+    const root = opts.path || process.cwd();
+    const nxJson = (0, configuration_1.readNxJson)(root);
+    try {
+        const projectGraph = (0, project_graph_1.readCachedProjectGraph)();
+        configuration = {
+            ...nxJson,
+            ...(0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph),
+        };
+    }
+    catch {
+        configuration = {
+            version: 2,
+            projects: getProjectsSyncNoInference(root, nxJson).projects,
+        };
+    }
+    if (opts.format === 'angularCli') {
+        return (0, angular_json_1.toOldFormat)(configuration);
+    }
+    else {
+        return configuration;
+    }
+}
+exports.readWorkspaceConfig = readWorkspaceConfig;
+function defaultFileRead(filePath) {
+    return (0, fs_1.readFileSync)((0, path_1.join)(workspace_root_1.workspaceRoot, filePath), 'utf-8');
+}
+exports.defaultFileRead = defaultFileRead;
+function readPackageJson() {
+    try {
+        return (0, fileutils_1.readJsonFile)(`${workspace_root_1.workspaceRoot}/package.json`);
+    }
+    catch {
+        return {}; // if package.json doesn't exist
+    }
+}
+exports.readPackageJson = readPackageJson;
+// TODO(17): Remove these exports
+var configuration_2 = require("../config/configuration");
+Object.defineProperty(exports, "readNxJson", { enumerable: true, get: function () { return configuration_2.readNxJson; } });
+Object.defineProperty(exports, "workspaceLayout", { enumerable: true, get: function () { return configuration_2.workspaceLayout; } });
+/**
+ * TODO(v19): Remove this function.
+ */
+function getProjectsSyncNoInference(root, nxJson) {
+    const projectFiles = (0, retrieve_workspace_files_1.retrieveProjectConfigurationPaths)(root, (0, nx_plugin_deprecated_1.getDefaultPluginsSync)(root));
+    const plugins = [
+        { plugin: package_json_next_to_project_json_1.PackageJsonProjectsNextToProjectJsonPlugin },
+        ...(0, nx_plugin_deprecated_1.getDefaultPluginsSync)(root),
+    ];
+    const projectRootMap = new Map();
+    // We iterate over plugins first - this ensures that plugins specified first take precedence.
+    for (const { plugin, options } of plugins) {
+        const [pattern, createNodes] = plugin.createNodes ?? [];
+        if (!pattern) {
+            continue;
+        }
+        for (const file of projectFiles) {
+            if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
+                let r = createNodes(file, options, {
+                    nxJsonConfiguration: nxJson,
+                    workspaceRoot: root,
+                });
+                for (const node in r.projects) {
+                    const project = {
+                        root: node,
+                        ...r.projects[node],
+                    };
+                    (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(projectRootMap, project);
+                }
+            }
+        }
+    }
+    return {
+        projects: (0, project_configuration_utils_1.readProjectConfigurationsFromRootMap)(projectRootMap),
+    };
+}

package/src/project-graph/nx-deps-cache.d.ts

@@ -0,0 +1,48 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { FileData, FileMap, ProjectGraph } from '../config/project-graph';
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+export interface FileMapCache {
+    version: string;
+    nxVersion: string;
+    deps: Record<string, string>;
+    pathMappings: Record<string, any>;
+    nxJsonPlugins: PluginData[];
+    pluginsConfig?: any;
+    fileMap: FileMap;
+}
+export declare const nxProjectGraph: string;
+export declare const nxFileMap: string;
+export declare function ensureCacheDirectory(): void;
+export declare function readFileMapCache(): null | FileMapCache;
+export declare function readProjectGraphCache(): null | ProjectGraph;
+export declare function createProjectFileMapCache(nxJson: NxJsonConfiguration<'*' | string[]>, packageJsonDeps: Record<string, string>, fileMap: FileMap, tsConfig: {
+    compilerOptions?: {
+        paths?: {
+            [p: string]: any;
+        };
+    };
+}): FileMapCache;
+export declare function writeCache(cache: FileMapCache, projectGraph: ProjectGraph): void;
+export declare function shouldRecomputeWholeGraph(cache: FileMapCache, packageJsonDeps: Record<string, string>, projects: Record<string, ProjectConfiguration>, nxJson: NxJsonConfiguration, tsConfig: {
+    compilerOptions: {
+        paths: {
+            [k: string]: any;
+        };
+    };
+}): boolean;
+export type CachedFileData = {
+    nonProjectFiles: Record<string, FileData>;
+    projectFileMap: {
+        [project: string]: Record<string, FileData>;
+    };
+};
+export declare function extractCachedFileData(fileMap: FileMap, c: FileMapCache): {
+    filesToProcess: FileMap;
+    cachedFileData: CachedFileData;
+};
+type PluginData = {
+    name: string;
+    version: string;
+    options?: unknown;
+};
+export {};

package/src/project-graph/nx-deps-cache.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCachedFileData = exports.shouldRecomputeWholeGraph = exports.writeCache = exports.createProjectFileMapCache = exports.readProjectGraphCache = exports.readFileMapCache = exports.ensureCacheDirectory = exports.nxFileMap = exports.nxProjectGraph = void 0;
+const fs_1 = require("fs");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
+const cache_directory_1 = require("../utils/cache-directory");
+const fileutils_1 = require("../utils/fileutils");
+const versions_1 = require("../utils/versions");
+exports.nxProjectGraph = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'project-graph.json');
+exports.nxFileMap = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'file-map.json');
+function ensureCacheDirectory() {
+    try {
+        if (!(0, fs_1.existsSync)(cache_directory_1.projectGraphCacheDirectory)) {
+            (0, fs_extra_1.ensureDirSync)(cache_directory_1.projectGraphCacheDirectory);
+        }
+    }
+    catch (e) {
+        /*
+         * @jeffbcross: Node JS docs recommend against checking for existence of directory immediately before creating it.
+         * Instead, just try to create the directory and handle the error.
+         *
+         * We ran into race conditions when running scripts concurrently, where multiple scripts were
+         * arriving here simultaneously, checking for directory existence, then trying to create the directory simultaneously.
+         *
+         * In this case, we're creating the directory. If the operation failed, we ensure that the directory
+         * exists before continuing (or raise an exception).
+         */
+        if (!(0, fileutils_1.directoryExists)(cache_directory_1.projectGraphCacheDirectory)) {
+            throw new Error(`Failed to create directory: ${cache_directory_1.projectGraphCacheDirectory}`);
+        }
+    }
+}
+exports.ensureCacheDirectory = ensureCacheDirectory;
+function readFileMapCache() {
+    perf_hooks_1.performance.mark('read cache:start');
+    ensureCacheDirectory();
+    let data = null;
+    try {
+        if ((0, fileutils_1.fileExists)(exports.nxFileMap)) {
+            data = (0, fileutils_1.readJsonFile)(exports.nxFileMap);
+        }
+    }
+    catch (error) {
+        console.log(`Error reading '${exports.nxFileMap}'. Continue the process without the cache.`);
+        console.log(error);
+    }
+    perf_hooks_1.performance.mark('read cache:end');
+    perf_hooks_1.performance.measure('read cache', 'read cache:start', 'read cache:end');
+    return data ?? null;
+}
+exports.readFileMapCache = readFileMapCache;
+function readProjectGraphCache() {
+    perf_hooks_1.performance.mark('read project-graph:start');
+    ensureCacheDirectory();
+    let data = null;
+    try {
+        if ((0, fileutils_1.fileExists)(exports.nxProjectGraph)) {
+            data = (0, fileutils_1.readJsonFile)(exports.nxProjectGraph);
+        }
+    }
+    catch (error) {
+        console.log(`Error reading '${exports.nxProjectGraph}'. Continue the process without the cache.`);
+        console.log(error);
+    }
+    perf_hooks_1.performance.mark('read project-graph:end');
+    perf_hooks_1.performance.measure('read cache', 'read project-graph:start', 'read project-graph:end');
+    return data ?? null;
+}
+exports.readProjectGraphCache = readProjectGraphCache;
+function createProjectFileMapCache(nxJson, packageJsonDeps, fileMap, tsConfig) {
+    const nxJsonPlugins = getNxJsonPluginsData(nxJson, packageJsonDeps);
+    const newValue = {
+        version: '6.0',
+        nxVersion: versions_1.nxVersion,
+        deps: packageJsonDeps, // TODO(v19): We can remove this in favor of nxVersion
+        // compilerOptions may not exist, especially for package-based repos
+        pathMappings: tsConfig?.compilerOptions?.paths || {},
+        nxJsonPlugins,
+        pluginsConfig: nxJson?.pluginsConfig,
+        fileMap,
+    };
+    return newValue;
+}
+exports.createProjectFileMapCache = createProjectFileMapCache;
+function writeCache(cache, projectGraph) {
+    perf_hooks_1.performance.mark('write cache:start');
+    let retry = 1;
+    let done = false;
+    do {
+        // write first to a unique temporary filename and then do a
+        // rename of the file to the correct filename
+        // this is to avoid any problems with half-written files
+        // in case of crash and/or partially written files due
+        // to multiple parallel processes reading and writing this file
+        const unique = (Math.random().toString(16) + '0000000').slice(2, 10);
+        const tmpProjectGraphPath = `${exports.nxProjectGraph}~${unique}`;
+        const tmpFileMapPath = `${exports.nxFileMap}~${unique}`;
+        try {
+            (0, fileutils_1.writeJsonFile)(tmpProjectGraphPath, projectGraph);
+            (0, fs_extra_1.renameSync)(tmpProjectGraphPath, exports.nxProjectGraph);
+            (0, fileutils_1.writeJsonFile)(tmpFileMapPath, cache);
+            (0, fs_extra_1.renameSync)(tmpFileMapPath, exports.nxFileMap);
+            done = true;
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                console.log(`ERROR (${retry}) when writing \n${err.message}\n${err.stack}`);
+            }
+            else {
+                console.log(`ERROR  (${retry}) unknown error when writing ${exports.nxProjectGraph} and ${exports.nxFileMap}`);
+            }
+            ++retry;
+        }
+    } while (!done && retry < 5);
+    perf_hooks_1.performance.mark('write cache:end');
+    perf_hooks_1.performance.measure('write cache', 'write cache:start', 'write cache:end');
+}
+exports.writeCache = writeCache;
+function shouldRecomputeWholeGraph(cache, packageJsonDeps, projects, nxJson, tsConfig) {
+    if (cache.version !== '6.0') {
+        return true;
+    }
+    if (cache.nxVersion !== versions_1.nxVersion) {
+        return true;
+    }
+    // we have a cached project that is no longer present
+    const cachedNodes = Object.keys(cache.fileMap.projectFileMap);
+    if (cachedNodes.some((p) => projects[p] === undefined)) {
+        return true;
+    }
+    // a path mapping for an existing project has changed
+    if (Object.keys(cache.pathMappings).some((t) => {
+        const cached = cache.pathMappings && cache.pathMappings[t]
+            ? JSON.stringify(cache.pathMappings[t])
+            : undefined;
+        const notCached = tsConfig?.compilerOptions?.paths && tsConfig?.compilerOptions?.paths[t]
+            ? JSON.stringify(tsConfig.compilerOptions.paths[t])
+            : undefined;
+        return cached !== notCached;
+    })) {
+        return true;
+    }
+    // a new plugin has been added
+    if (JSON.stringify(getNxJsonPluginsData(nxJson, packageJsonDeps)) !==
+        JSON.stringify(cache.nxJsonPlugins)) {
+        return true;
+    }
+    if (JSON.stringify(nxJson?.pluginsConfig) !==
+        JSON.stringify(cache.pluginsConfig)) {
+        return true;
+    }
+    return false;
+}
+exports.shouldRecomputeWholeGraph = shouldRecomputeWholeGraph;
+/*
+This can only be invoked when the list of projects is either the same
+or new projects have been added, so every project in the cache has a corresponding
+project in fileMap
+*/
+function extractCachedFileData(fileMap, c) {
+    const filesToProcess = {
+        nonProjectFiles: [],
+        projectFileMap: {},
+    };
+    const cachedFileData = {
+        nonProjectFiles: {},
+        projectFileMap: {},
+    };
+    const currentProjects = Object.keys(fileMap.projectFileMap).filter((name) => fileMap.projectFileMap[name].length > 0);
+    currentProjects.forEach((p) => {
+        processProjectNode(p, c.fileMap.projectFileMap, cachedFileData.projectFileMap, filesToProcess.projectFileMap, fileMap);
+    });
+    processNonProjectFiles(c.fileMap.nonProjectFiles, fileMap.nonProjectFiles, filesToProcess.nonProjectFiles, cachedFileData.nonProjectFiles);
+    return {
+        filesToProcess,
+        cachedFileData,
+    };
+}
+exports.extractCachedFileData = extractCachedFileData;
+function processNonProjectFiles(cachedFiles, nonProjectFiles, filesToProcess, cachedFileData) {
+    const cachedHashMap = new Map(cachedFiles.map((f) => [f.file, f]));
+    for (const f of nonProjectFiles) {
+        const cachedFile = cachedHashMap.get(f.file);
+        if (!cachedFile || cachedFile.hash !== f.hash) {
+            filesToProcess.push(f);
+        }
+        else {
+            cachedFileData[f.file] = cachedFile;
+        }
+    }
+}
+function processProjectNode(projectName, cachedFileMap, cachedFileData, filesToProcess, { projectFileMap }) {
+    if (!cachedFileMap[projectName]) {
+        filesToProcess[projectName] = projectFileMap[projectName];
+        return;
+    }
+    const fileDataFromCache = {};
+    for (let f of cachedFileMap[projectName]) {
+        fileDataFromCache[f.file] = f;
+    }
+    if (!cachedFileData[projectName]) {
+        cachedFileData[projectName] = {};
+    }
+    for (let f of projectFileMap[projectName]) {
+        const fromCache = fileDataFromCache[f.file];
+        if (fromCache && fromCache.hash == f.hash) {
+            cachedFileData[projectName][f.file] = fromCache;
+        }
+        else {
+            if (!filesToProcess[projectName]) {
+                filesToProcess[projectName] = [];
+            }
+            filesToProcess[projectName].push(f);
+        }
+    }
+}
+function getNxJsonPluginsData(nxJson, packageJsonDeps) {
+    return (nxJson?.plugins || []).map((p) => {
+        const [plugin, options] = typeof p === 'string' ? [p] : [p.plugin, p.options];
+        return {
+            name: plugin,
+            version: packageJsonDeps[plugin],
+            options,
+        };
+    });
+}

package/src/project-graph/operators.d.ts

@@ -0,0 +1,12 @@
+import { ProjectGraph, ProjectGraphExternalNode, ProjectGraphProjectNode } from '../config/project-graph';
+/**
+ * Returns a new project graph where all the edges are reversed.
+ *
+ * For instance, if project A depends on B, in the reversed graph
+ * B will depend on A.
+ */
+export declare function reverse(graph: ProjectGraph): ProjectGraph;
+export declare function filterNodes(predicate?: (n: ProjectGraphProjectNode) => boolean): (p: ProjectGraph) => ProjectGraph;
+export declare function isNpmProject(project: ProjectGraphProjectNode | ProjectGraphExternalNode): project is ProjectGraphExternalNode;
+export declare const pruneExternalNodes: (p: ProjectGraph) => ProjectGraph;
+export declare function withDeps(original: ProjectGraph, subsetNodes: ProjectGraphProjectNode[]): ProjectGraph;

package/src/project-graph/operators.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withDeps = exports.pruneExternalNodes = exports.isNpmProject = exports.filterNodes = exports.reverse = void 0;
+const reverseMemo = new Map();
+/**
+ * Returns a new project graph where all the edges are reversed.
+ *
+ * For instance, if project A depends on B, in the reversed graph
+ * B will depend on A.
+ */
+function reverse(graph) {
+    const resultFromMemo = reverseMemo.get(graph);
+    if (resultFromMemo) {
+        return resultFromMemo;
+    }
+    const result = {
+        ...graph,
+        nodes: { ...graph.nodes },
+        externalNodes: { ...graph.externalNodes },
+        dependencies: {},
+    };
+    Object.keys(graph.nodes).forEach((n) => (result.dependencies[n] = []));
+    // we need to keep external node's reverse dependencies to trace our route back
+    if (graph.externalNodes) {
+        Object.keys(graph.externalNodes).forEach((n) => (result.dependencies[n] = []));
+    }
+    Object.values(graph.dependencies).forEach((byProject) => {
+        byProject.forEach((dep) => {
+            const dependency = result.dependencies[dep.target];
+            if (dependency) {
+                dependency.push({
+                    type: dep.type,
+                    source: dep.target,
+                    target: dep.source,
+                });
+            }
+        });
+    });
+    reverseMemo.set(graph, result);
+    reverseMemo.set(result, graph);
+    return result;
+}
+exports.reverse = reverse;
+function filterNodes(predicate) {
+    return (original) => {
+        const graph = { nodes: {}, dependencies: {} };
+        const added = new Set();
+        Object.values(original.nodes).forEach((n) => {
+            if (!predicate || predicate(n)) {
+                graph.nodes[n.name] = n;
+                graph.dependencies[n.name] = [];
+                added.add(n.name);
+            }
+        });
+        Object.values(original.dependencies).forEach((ds) => {
+            ds.forEach((d) => {
+                if (added.has(d.source) && added.has(d.target)) {
+                    graph.dependencies[d.source].push(d);
+                }
+            });
+        });
+        return graph;
+    };
+}
+exports.filterNodes = filterNodes;
+function isNpmProject(project) {
+    return project?.type === 'npm';
+}
+exports.isNpmProject = isNpmProject;
+exports.pruneExternalNodes = filterNodes();
+function withDeps(original, subsetNodes) {
+    const res = { nodes: {}, dependencies: {} };
+    const visitedNodes = [];
+    const visitedEdges = [];
+    Object.values(subsetNodes).forEach(recurNodes);
+    Object.values(subsetNodes).forEach(recurEdges);
+    return res;
+    // ---------------------------------------------------------------------------
+    function recurNodes(node) {
+        if (visitedNodes.indexOf(node.name) > -1)
+            return;
+        res.nodes[node.name] = node;
+        if (!res.dependencies[node.name]) {
+            res.dependencies[node.name] = [];
+        }
+        visitedNodes.push(node.name);
+        original.dependencies[node.name].forEach((n) => {
+            if (original.nodes[n.target]) {
+                recurNodes(original.nodes[n.target]);
+            }
+        });
+    }
+    function recurEdges(node) {
+        if (visitedEdges.indexOf(node.name) > -1)
+            return;
+        visitedEdges.push(node.name);
+        const ds = original.dependencies[node.name];
+        ds.forEach((n) => {
+            if (!original.nodes[n.target]) {
+                return;
+            }
+            if (!res.dependencies[n.source]) {
+                res.dependencies[n.source] = [];
+            }
+            res.dependencies[n.source].push(n);
+        });
+        ds.forEach((n) => {
+            if (original.nodes[n.target]) {
+                recurEdges(original.nodes[n.target]);
+            }
+        });
+    }
+}
+exports.withDeps = withDeps;