@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

package/dist/src/project-graph/project-graph.js

@@ -0,0 +1,461 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCachedProjectGraph = readCachedProjectGraph;
+exports.readCachedProjectConfiguration = readCachedProjectConfiguration;
+exports.readProjectsConfigurationFromProjectGraph = readProjectsConfigurationFromProjectGraph;
+exports.buildProjectGraphAndSourceMapsWithoutDaemon = buildProjectGraphAndSourceMapsWithoutDaemon;
+exports.handleProjectGraphError = handleProjectGraphError;
+exports.createProjectGraphAsync = createProjectGraphAsync;
+exports.createProjectGraphAndSourceMapsAsync = createProjectGraphAndSourceMapsAsync;
+exports.preventRecursionInGraphConstruction = preventRecursionInGraphConstruction;
+const perf_hooks_1 = require("perf_hooks");
+const path_1 = require("path");
+const analytics_1 = require("../analytics");
+const nx_json_1 = require("../config/nx-json");
+const client_1 = require("../daemon/client/client");
+const is_on_daemon_1 = require("../daemon/is-on-daemon");
+const sandbox_socket_hint_1 = require("../daemon/sandbox-socket-hint");
+const tmp_dir_1 = require("../daemon/tmp-dir");
+const native_1 = require("../native");
+const cache_directory_1 = require("../utils/cache-directory");
+const call_sites_1 = require("../utils/call-sites");
+const delayed_spinner_1 = require("../utils/delayed-spinner");
+const fileutils_1 = require("../utils/fileutils");
+const is_sandbox_1 = require("../utils/is-sandbox");
+const logger_1 = require("../utils/logger");
+const output_1 = require("../utils/output");
+const strip_indents_1 = require("../utils/strip-indents");
+const workspace_root_1 = require("../utils/workspace-root");
+const workspace_context_1 = require("../utils/workspace-context");
+const build_project_graph_1 = require("./build-project-graph");
+const error_types_1 = require("./error-types");
+const nx_deps_cache_1 = require("./nx-deps-cache");
+const nx_plugin_capabilities_1 = require("./plugins/nx-plugin-capabilities");
+const get_plugins_1 = require("./plugins/get-plugins");
+const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
+const handle_import_1 = require("../utils/handle-import");
+/**
+ * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
+ *
+ * @param {number} [minimumComputedAt] - The minimum timestamp that the cached ProjectGraph must have been computed at.
+ * @throws {Error} if there is no cached ProjectGraph to read from
+ */
+function readCachedProjectGraph(minimumComputedAt) {
+    const cached = (0, nx_deps_cache_1.readProjectGraphCache)(minimumComputedAt);
+    if (!cached) {
+        throw noCachedProjectGraphError();
+    }
+    return cached.projectGraph;
+}
+function noCachedProjectGraphError() {
+    const angularSpecificError = (0, fileutils_1.fileExists)(`${workspace_root_1.workspaceRoot}/angular.json`)
+        ? (0, strip_indents_1.stripIndents) `
+      Make sure invoke 'node ./decorate-angular-cli.js' in your postinstall script.
+      The decorated CLI will compute the project graph.
+      'ng --help' should say 'Smart Monorepos · Fast Builds'.
+      `
+        : '';
+    return new Error((0, strip_indents_1.stripIndents) `
+      [readCachedProjectGraph] ERROR: No cached ProjectGraph is available.
+
+      If you are leveraging \`readCachedProjectGraph()\` directly then you will need to refactor your usage to first ensure that
+      the ProjectGraph is created by calling \`await createProjectGraphAsync()\` somewhere before attempting to read the data.
+
+      If you encounter this error as part of running standard \`nx\` commands then please open an issue on https://github.com/nrwl/nx
+
+      ${angularSpecificError}
+    `);
+}
+function readCachedProjectConfiguration(projectName) {
+    const graph = readCachedProjectGraph();
+    const node = graph.nodes[projectName];
+    try {
+        return node.data;
+    }
+    catch (e) {
+        throw new Error(`Cannot find project: '${projectName}' in your workspace.`);
+    }
+}
+/**
+ * Get the {@link ProjectsConfigurations} from the {@link ProjectGraph}
+ */
+function readProjectsConfigurationFromProjectGraph(projectGraph) {
+    return {
+        projects: Object.fromEntries(Object.entries(projectGraph.nodes).map(([project, { data }]) => [
+            project,
+            data,
+        ])),
+        version: 2,
+    };
+}
+async function buildProjectGraphAndSourceMapsWithoutDaemon() {
+    preventRecursionInGraphConstruction();
+    // Answer from the plugins loaded below, not an earlier cached graph's rows.
+    (0, nx_plugin_capabilities_1.noteGraphReadFromCache)(undefined);
+    global.NX_GRAPH_CREATION = true;
+    const nxJson = (0, nx_json_1.readNxJson)();
+    (0, workspace_context_1.refreshWorkspaceContext)(workspace_root_1.workspaceRoot);
+    perf_hooks_1.performance.mark('retrieve-project-configurations:start');
+    let configurationResult;
+    let projectConfigurationsError;
+    const separatedPlugins = await (0, get_plugins_1.getPluginsSeparated)(nxJson);
+    const plugins = separatedPlugins.specifiedPlugins.concat(separatedPlugins.defaultPlugins);
+    try {
+        configurationResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(separatedPlugins, workspace_root_1.workspaceRoot, nxJson);
+    }
+    catch (e) {
+        if (e instanceof error_types_1.ProjectConfigurationsError) {
+            projectConfigurationsError = e;
+            configurationResult = e.partialProjectConfigurationsResult;
+        }
+        else {
+            throw e;
+        }
+    }
+    const { projects, externalNodes, sourceMaps, projectRootMap } = configurationResult;
+    perf_hooks_1.performance.mark('retrieve-project-configurations:end');
+    perf_hooks_1.performance.mark('retrieve-workspace-files:start');
+    const { fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+    perf_hooks_1.performance.mark('retrieve-workspace-files:end');
+    const cacheEnabled = process.env.NX_CACHE_PROJECT_GRAPH !== 'false';
+    perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:start');
+    let projectGraphError;
+    let projectGraphResult;
+    try {
+        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins, sourceMaps);
+    }
+    catch (e) {
+        if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
+            projectGraphResult = {
+                projectGraph: e.partialProjectGraph,
+                projectFileMapCache: null,
+            };
+            projectGraphError = e;
+        }
+        else {
+            throw e;
+        }
+    }
+    const { projectGraph, projectFileMapCache } = projectGraphResult;
+    perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:end');
+    delete global.NX_GRAPH_CREATION;
+    const errors = [
+        ...(projectConfigurationsError?.errors ?? []),
+        ...(projectGraphError?.errors ?? []),
+    ];
+    if (cacheEnabled) {
+        const computedAt = Date.now();
+        // Before the graph, so a cached graph never lacks its row.
+        if (errors.length === 0) {
+            (0, nx_plugin_capabilities_1.getNxPluginCapabilitiesStore)()?.record(computedAt, plugins.map((plugin) => plugin.capabilities()));
+        }
+        (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph, sourceMaps, errors, computedAt);
+    }
+    if (errors.length > 0) {
+        throw new error_types_1.ProjectGraphError(errors, projectGraph, sourceMaps);
+    }
+    else {
+        return { projectGraph, sourceMaps };
+    }
+}
+function handleProjectGraphError(opts, e) {
+    if (opts.exitOnError) {
+        const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
+        if (e instanceof error_types_1.ProjectGraphError) {
+            output_1.output.error((0, error_types_1.formatProjectGraphError)(e, isVerbose));
+        }
+        else if (typeof e.message === 'string') {
+            const lines = e.message.split('\n');
+            output_1.output.error({
+                title: lines[0],
+                bodyLines: lines.slice(1),
+            });
+            if (isVerbose) {
+                console.error(e);
+            }
+        }
+        else {
+            console.error(e);
+        }
+        process.exit(1);
+    }
+    else {
+        throw e;
+    }
+}
+async function readCachedGraphAndHydrateFileMap(minimumComputedAt) {
+    const cached = (0, nx_deps_cache_1.readProjectGraphCache)(minimumComputedAt);
+    if (!cached) {
+        throw noCachedProjectGraphError();
+    }
+    const graph = cached.projectGraph;
+    (0, nx_plugin_capabilities_1.noteGraphReadFromCache)(cached.computedAt);
+    const projectRootMap = Object.fromEntries(Object.entries(graph.nodes).map(([project, { data }]) => [
+        data.root,
+        project,
+    ]));
+    const { fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+    (0, build_project_graph_1.hydrateFileMap)(fileMap, rustReferences);
+    return graph;
+}
+/**
+ * Computes and returns a ProjectGraph.
+ *
+ * Nx will compute the graph either in a daemon process or in the current process.
+ *
+ * Nx will compute it in the current process if:
+ * * The process is running in CI (CI env variable is to true or other common variables used by CI providers are set).
+ * * It is running in the docker container.
+ * * The daemon process is disabled because of the previous error when starting the daemon.
+ * * `NX_DAEMON` is set to `false`.
+ * * `useDaemonProcess` is set to false in the options of the tasks runner inside `nx.json`
+ *
+ * `NX_DAEMON` env variable takes precedence:
+ * * If it is set to true, the daemon will always be used.
+ * * If it is set to false, the graph will always be computed in the current process.
+ *
+ * Tip: If you want to debug project graph creation, run your command with NX_DAEMON=false.
+ *
+ * Nx uses two layers of caching: the information about explicit dependencies stored on the disk and the information
+ * stored in the daemon process. To reset both run: `nx reset`.
+ */
+async function createProjectGraphAsync(opts = {
+    exitOnError: false,
+    resetDaemonClient: false,
+}) {
+    if (process.env.NX_FORCE_REUSE_CACHED_GRAPH === 'true') {
+        try {
+            // If no cached graph is found, we will fall through to the normal flow
+            const graph = await readCachedGraphAndHydrateFileMap();
+            return graph;
+        }
+        catch (e) {
+            if (e instanceof error_types_1.ProjectGraphError) {
+                throw e;
+            }
+            logger_1.logger.verbose('Unable to use cached project graph', e);
+        }
+    }
+    const projectGraphAndSourceMaps = await createProjectGraphAndSourceMapsAsync(opts);
+    return projectGraphAndSourceMaps.projectGraph;
+}
+async function createProjectGraphAndSourceMapsAsync(opts = {
+    exitOnError: false,
+    resetDaemonClient: false,
+}) {
+    perf_hooks_1.performance.mark('createProjectGraphAsync:start');
+    // If we're already on the daemon, return the in-memory graph directly
+    // instead of making an IPC call back to ourselves.
+    if ((0, is_on_daemon_1.isOnDaemon)()) {
+        const { currentProjectGraph, currentSourceMaps } = await (0, handle_import_1.handleImport)('../daemon/server/project-graph-incremental-recomputation.js', __dirname);
+        if (currentProjectGraph) {
+            perf_hooks_1.performance.mark('createProjectGraphAsync:end');
+            perf_hooks_1.performance.measure('createProjectGraphAsync', {
+                start: 'createProjectGraphAsync:start',
+                end: 'createProjectGraphAsync:end',
+                detail: {
+                    track: true,
+                    ...(analytics_1.customDimensions && {
+                        [analytics_1.customDimensions.projectCount]: Object.keys(currentProjectGraph.nodes).length,
+                        [analytics_1.customDimensions.sampleRate]: analytics_1.PERF_SPAN_SAMPLE_RATE,
+                    }),
+                },
+            });
+            return {
+                projectGraph: currentProjectGraph,
+                sourceMaps: currentSourceMaps,
+            };
+        }
+    }
+    if (!client_1.daemonClient.enabled()) {
+        const lock = !native_1.IS_WASM
+            ? new native_1.FileLock((0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'project-graph.lock'))
+            : null;
+        let holdingLock = lock?.tryLock() ?? false;
+        while (lock && !holdingLock) {
+            logger_1.logger.verbose('Waiting for graph construction in another process to complete');
+            const spinner = new delayed_spinner_1.DelayedSpinner('Waiting for graph construction in another process to complete');
+            const start = Date.now();
+            try {
+                await lock.wait();
+                // A graph computed after this process started waiting is the holder's.
+                const graph = await readCachedGraphAndHydrateFileMap(start);
+                const sourceMaps = (0, nx_deps_cache_1.readSourceMapsCache)();
+                if (!sourceMaps) {
+                    throw new Error('The project graph was computed in another process, but the source maps are missing.');
+                }
+                return { projectGraph: graph, sourceMaps };
+            }
+            catch (e) {
+                if (!(e instanceof error_types_1.StaleProjectGraphCacheError)) {
+                    throw e;
+                }
+                // The holder stopped without writing a graph: build it here, or wait for
+                // whoever took the lock first.
+                holdingLock = lock.tryLock();
+            }
+            finally {
+                spinner.cleanup();
+            }
+        }
+        try {
+            const res = await buildProjectGraphAndSourceMapsWithoutDaemon();
+            perf_hooks_1.performance.measure('createProjectGraphAsync >> retrieve-project-configurations', 'retrieve-project-configurations:start', 'retrieve-project-configurations:end');
+            perf_hooks_1.performance.measure('createProjectGraphAsync >> retrieve-workspace-files', 'retrieve-workspace-files:start', 'retrieve-workspace-files:end');
+            perf_hooks_1.performance.measure('createProjectGraphAsync >> build-project-graph-using-project-file-map', 'build-project-graph-using-project-file-map:start', 'build-project-graph-using-project-file-map:end');
+            perf_hooks_1.performance.mark('createProjectGraphAsync:end');
+            perf_hooks_1.performance.measure('createProjectGraphAsync', {
+                start: 'createProjectGraphAsync:start',
+                end: 'createProjectGraphAsync:end',
+                detail: {
+                    track: true,
+                    ...(analytics_1.customDimensions && {
+                        [analytics_1.customDimensions.projectCount]: Object.keys(res.projectGraph.nodes)
+                            .length,
+                        [analytics_1.customDimensions.sampleRate]: analytics_1.PERF_SPAN_SAMPLE_RATE,
+                    }),
+                },
+            });
+            return res;
+        }
+        catch (e) {
+            handleProjectGraphError(opts, e);
+        }
+        finally {
+            if (holdingLock) {
+                lock.unlock();
+            }
+        }
+    }
+    else {
+        try {
+            const projectGraphAndSourceMaps = await client_1.daemonClient.getProjectGraphAndSourceMaps();
+            perf_hooks_1.performance.mark('createProjectGraphAsync:end');
+            perf_hooks_1.performance.measure('createProjectGraphAsync', {
+                start: 'createProjectGraphAsync:start',
+                end: 'createProjectGraphAsync:end',
+                detail: {
+                    track: true,
+                    ...(analytics_1.customDimensions && {
+                        [analytics_1.customDimensions.projectCount]: Object.keys(projectGraphAndSourceMaps.projectGraph.nodes).length,
+                        [analytics_1.customDimensions.sampleRate]: analytics_1.PERF_SPAN_SAMPLE_RATE,
+                    }),
+                },
+            });
+            return projectGraphAndSourceMaps;
+        }
+        catch (e) {
+            if (e.message && e.message.indexOf('inotify_add_watch') > -1) {
+                // common errors with the daemon due to OS settings (cannot watch all the files available)
+                output_1.output.note({
+                    title: `Unable to start Nx Daemon due to the limited amount of inotify watches, continuing without the daemon.`,
+                    bodyLines: [
+                        'For more information read: https://askubuntu.com/questions/1088272/inotify-add-watch-failed-no-space-left-on-device',
+                        'Nx Daemon is going to be disabled until you run "nx reset".',
+                    ],
+                });
+                (0, tmp_dir_1.markDaemonAsDisabled)(e.message);
+                return buildProjectGraphAndSourceMapsWithoutDaemon();
+            }
+            if (e.daemonPermissionError) {
+                // Deliberately not disabled: unlike the inotify limit above, a socket
+                // owned by someone else stops being there when it is removed or the
+                // machine reboots, and disabling until `nx reset` would outlive the
+                // cause and hide the fix from anyone who followed the advice.
+                // The first line carries the errno, and it is the one token that tells
+                // the two causes apart: EACCES is a socket owned by someone else (delete
+                // it), EPERM is a sandbox refusing the connect syscall (allow unix
+                // sockets under the Nx socket root). The message hedges between exactly
+                // those two because it cannot tell them apart, and this branch does not
+                // call writeDaemonLogs, so dropping the line loses the errno for good.
+                const [summary, ...details] = e.message.split('\n');
+                output_1.output.note({
+                    title: `${summary} Continuing without the daemon.`,
+                    // The blank line after the summary separates paragraphs when the
+                    // message is printed as one blob; as bodyLines it is a leading gap.
+                    bodyLines: details[0] === '' ? details.slice(1) : details,
+                });
+                return buildProjectGraphAndSourceMapsWithoutDaemon();
+            }
+            if (e.internalDaemonError) {
+                const errorLogFile = (0, tmp_dir_1.writeDaemonLogs)(e.message);
+                const sandboxed = (0, is_sandbox_1.isSandbox)();
+                output_1.output.warn({
+                    title: `Nx Daemon was not able to compute the project graph.`,
+                    bodyLines: [
+                        `Log file with the error: ${errorLogFile}`,
+                        // Inline rather than left to the log file, which an agent will
+                        // not open. This branch covers every internal daemon error,
+                        // including ones a sandbox cannot explain, so the issue link stays
+                        // either way.
+                        ...(sandboxed ? (0, sandbox_socket_hint_1.sandboxSocketHint)() : []),
+                        `Please file an issue at https://github.com/nrwl/nx`,
+                        sandboxed
+                            ? 'Nx Daemon is disabled for this command.'
+                            : 'Nx Daemon is going to be disabled until you run "nx reset".',
+                    ],
+                });
+                // A sandbox refusal describes the environment, not the workspace. The
+                // on-disk marker would follow the checkout into an ordinary terminal
+                // and survive the user fixing their allowlist, since only `nx reset`
+                // clears it.
+                if (sandboxed) {
+                    (0, tmp_dir_1.disableDaemonForThisProcess)(e.message);
+                }
+                else {
+                    (0, tmp_dir_1.markDaemonAsDisabled)(e.message);
+                }
+                // Both writes are only read through `isDaemonDisabled()`, which
+                // `enabled()` consults once and then memoizes. Without clearing that,
+                // every later daemon consumer in this process — task hashing, workspace
+                // context, sync generators — starts the daemon again and waits out the
+                // full connect budget, under a warning saying it is off.
+                client_1.daemonClient.reset();
+                return buildProjectGraphAndSourceMapsWithoutDaemon();
+            }
+            handleProjectGraphError(opts, e);
+        }
+        finally {
+            if (opts.resetDaemonClient) {
+                client_1.daemonClient.reset();
+            }
+        }
+    }
+}
+function preventRecursionInGraphConstruction() {
+    const allFrames = (0, call_sites_1.getCallSites)();
+    // Find the first occurrence of buildProjectGraphAndSourceMapsWithoutDaemon in the call stack.
+    // This represents the current invocation and should be skipped for the recursion check.
+    const firstOccurrenceIndex = allFrames.findIndex((f) => f.getFunctionName() === buildProjectGraphAndSourceMapsWithoutDaemon.name);
+    let stackframes;
+    if (firstOccurrenceIndex !== -1) {
+        // Skip the current invocation frame and any consecutive frames with the same function name.
+        // Some runtimes (e.g. Bun) include extra async frames for the same call, which would
+        // otherwise cause a false positive loop detection.
+        let startIndex = firstOccurrenceIndex + 1;
+        while (startIndex < allFrames.length &&
+            allFrames[startIndex].getFunctionName() ===
+                buildProjectGraphAndSourceMapsWithoutDaemon.name) {
+            startIndex++;
+        }
+        stackframes = allFrames.slice(startIndex);
+    }
+    else {
+        // If buildProjectGraphAndSourceMapsWithoutDaemon is not in the stack (e.g., when called
+        // from daemon client), fall back to the original slice(2) behavior.
+        // preventRecursionInGraphConstruction -> callee -> ...
+        stackframes = allFrames.slice(2);
+    }
+    if (stackframes.some((f) => {
+        const functionName = f.getFunctionName();
+        const fileName = f.getFileName() || '';
+        return (functionName === buildProjectGraphAndSourceMapsWithoutDaemon.name ||
+            (['createNodes', 'createDependencies', 'createMetadata'].includes(functionName || '') &&
+                fileName.endsWith('plugin-worker.js')));
+    })) {
+        throw new Error(`Project graph construction cannot be performed due to a loop detected in the call stack. This can happen if 'createProjectGraphAsync' is called directly or indirectly during project graph construction.\n` +
+            'To avoid this, you can add a check against "global.NX_GRAPH_CREATION" before calling "createProjectGraphAsync".\n' +
+            'Call stack:\n' +
+            stackframes.join('\n'));
+    }
+}

package/dist/src/project-graph/utils/build-all-workspace-files.d.ts

@@ -0,0 +1,2 @@
+import { FileData, ProjectFileMap } from '../../config/project-graph';
+export declare function buildAllWorkspaceFiles(projectFileMap: ProjectFileMap, globalFiles: FileData[]): FileData[];

package/dist/src/project-graph/utils/build-all-workspace-files.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAllWorkspaceFiles = buildAllWorkspaceFiles;
+const perf_hooks_1 = require("perf_hooks");
+function buildAllWorkspaceFiles(projectFileMap, globalFiles) {
+    perf_hooks_1.performance.mark('get-all-workspace-files:start');
+    let fileData = Object.values(projectFileMap).flat();
+    fileData = fileData
+        .concat(globalFiles)
+        .sort((a, b) => a.file.localeCompare(b.file));
+    perf_hooks_1.performance.mark('get-all-workspace-files:end');
+    perf_hooks_1.performance.measure('get-all-workspace-files', 'get-all-workspace-files:start', 'get-all-workspace-files:end');
+    return fileData;
+}

package/dist/src/project-graph/utils/find-project-for-path.d.ts

@@ -0,0 +1,20 @@
+import { ProjectGraphProjectNode } from '../../config/project-graph';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+export type ProjectRootMappings = Map<string, string>;
+/**
+ * This creates a map of project roots to project names to easily look up the project of a file
+ * @param projects This is the map of project configurations commonly found in "workspace.json"
+ */
+export declare function createProjectRootMappingsFromProjectConfigurations(projects: Record<string, ProjectConfiguration>): ProjectRootMappings;
+/**
+ * This creates a map of project roots to project names to easily look up the project of a file
+ * @param nodes This is the nodes from the project graph
+ */
+export declare function createProjectRootMappings(nodes: Record<string, ProjectGraphProjectNode>): ProjectRootMappings;
+/**
+ * Locates a project in projectRootMap based on a file within it
+ * @param filePath path that is inside of projectName. This should be relative from the workspace root
+ * @param projectRootMap Map<projectRoot, projectName> Use {@link createProjectRootMappings} to create this
+ */
+export declare function findProjectForPath(filePath: string, projectRootMap: ProjectRootMappings): string | null;
+export declare function normalizeProjectRoot(root: string): string;

package/dist/src/project-graph/utils/find-project-for-path.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectRootMappingsFromProjectConfigurations = createProjectRootMappingsFromProjectConfigurations;
+exports.createProjectRootMappings = createProjectRootMappings;
+exports.findProjectForPath = findProjectForPath;
+exports.normalizeProjectRoot = normalizeProjectRoot;
+const path_1 = require("path");
+const path_2 = require("../../utils/path");
+/**
+ * This creates a map of project roots to project names to easily look up the project of a file
+ * @param projects This is the map of project configurations commonly found in "workspace.json"
+ */
+function createProjectRootMappingsFromProjectConfigurations(projects) {
+    const projectRootMappings = new Map();
+    for (const { name, root } of Object.values(projects)) {
+        projectRootMappings.set(normalizeProjectRoot(root), name);
+    }
+    return projectRootMappings;
+}
+/**
+ * This creates a map of project roots to project names to easily look up the project of a file
+ * @param nodes This is the nodes from the project graph
+ */
+function createProjectRootMappings(nodes) {
+    const projectRootMappings = new Map();
+    for (const projectName of Object.keys(nodes)) {
+        let root = nodes[projectName].data.root;
+        projectRootMappings.set(normalizeProjectRoot(root), projectName);
+    }
+    return projectRootMappings;
+}
+/**
+ * Locates a project in projectRootMap based on a file within it
+ * @param filePath path that is inside of projectName. This should be relative from the workspace root
+ * @param projectRootMap Map<projectRoot, projectName> Use {@link createProjectRootMappings} to create this
+ */
+function findProjectForPath(filePath, projectRootMap) {
+    /**
+     * Project Mappings are in UNIX-style file paths
+     * Windows may pass Win-style file paths
+     * Ensure filePath is in UNIX-style
+     */
+    let currentPath = (0, path_2.normalizePath)(filePath);
+    for (; currentPath != (0, path_1.dirname)(currentPath); currentPath = (0, path_1.dirname)(currentPath)) {
+        const p = projectRootMap.get(currentPath);
+        if (p) {
+            return p;
+        }
+    }
+    return projectRootMap.get(currentPath);
+}
+function normalizeProjectRoot(root) {
+    root = root === '' ? '.' : root;
+    return root && root.endsWith('/') ? root.substring(0, root.length - 1) : root;
+}

package/dist/src/project-graph/utils/implicit-project-dependencies.d.ts

@@ -0,0 +1,3 @@
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { ProjectGraphBuilder } from '../project-graph-builder';
+export declare function applyImplicitDependencies(projects: Record<string, ProjectConfiguration>, builder: ProjectGraphBuilder): void;

package/dist/src/project-graph/utils/implicit-project-dependencies.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyImplicitDependencies = applyImplicitDependencies;
+function applyImplicitDependencies(projects, builder) {
+    Object.keys(projects).forEach((source) => {
+        const p = projects[source];
+        if (p.implicitDependencies && p.implicitDependencies.length > 0) {
+            p.implicitDependencies.forEach((target) => {
+                if (target.startsWith('!')) {
+                    builder.removeDependency(source, target.slice(1));
+                }
+                else {
+                    builder.addImplicitDependency(source, target);
+                }
+            });
+        }
+    });
+}

package/dist/src/project-graph/utils/normalize-project-nodes.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectGraphProjectNode } from '../../config/project-graph';
+import type { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import type { CreateDependenciesContext } from '../plugins';
+import type { ProjectGraphBuilder } from '../project-graph-builder';
+export declare function normalizeProjectNodes({ projects, workspaceRoot }: CreateDependenciesContext, builder: ProjectGraphBuilder): Promise<void>;
+export declare function normalizeImplicitDependencies(source: string, implicitDependencies: ProjectConfiguration['implicitDependencies'], projects: Record<string, ProjectGraphProjectNode>): string[];