@ohos-ports/nx 19.8.4-beta.0

package/src/utils/sync-generators.js

@@ -0,0 +1,353 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncError = void 0;
+exports.getSyncGeneratorChanges = getSyncGeneratorChanges;
+exports.flushSyncGeneratorChanges = flushSyncGeneratorChanges;
+exports.collectAllRegisteredSyncGenerators = collectAllRegisteredSyncGenerators;
+exports.runSyncGenerator = runSyncGenerator;
+exports.collectEnabledTaskSyncGeneratorsFromProjectGraph = collectEnabledTaskSyncGeneratorsFromProjectGraph;
+exports.collectEnabledTaskSyncGeneratorsFromTaskGraph = collectEnabledTaskSyncGeneratorsFromTaskGraph;
+exports.collectRegisteredGlobalSyncGenerators = collectRegisteredGlobalSyncGenerators;
+exports.getSyncGeneratorSuccessResultsMessageLines = getSyncGeneratorSuccessResultsMessageLines;
+exports.getFailedSyncGeneratorsFixMessageLines = getFailedSyncGeneratorsFixMessageLines;
+exports.getFlushFailureMessageLines = getFlushFailureMessageLines;
+exports.processSyncGeneratorResultErrors = processSyncGeneratorResultErrors;
+const perf_hooks_1 = require("perf_hooks");
+const generate_1 = require("../command-line/generate/generate");
+const generator_utils_1 = require("../command-line/generate/generator-utils");
+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 tree_1 = require("../generators/tree");
+const project_graph_1 = require("../project-graph/project-graph");
+const workspace_context_1 = require("./workspace-context");
+const workspace_root_1 = require("./workspace-root");
+const chalk = require("chalk");
+class SyncError extends Error {
+    constructor(title, bodyLines) {
+        super(title);
+        this.title = title;
+        this.bodyLines = bodyLines;
+        this.name = this.constructor.name;
+    }
+}
+exports.SyncError = SyncError;
+async function getSyncGeneratorChanges(generators) {
+    perf_hooks_1.performance.mark('get-sync-generators-changes:start');
+    let results;
+    if (!client_1.daemonClient.enabled()) {
+        results = await runSyncGenerators(generators);
+    }
+    else {
+        results = await client_1.daemonClient.getSyncGeneratorChanges(generators);
+    }
+    perf_hooks_1.performance.mark('get-sync-generators-changes:end');
+    perf_hooks_1.performance.measure('get-sync-generators-changes', 'get-sync-generators-changes:start', 'get-sync-generators-changes:end');
+    return results.filter((r) => ('error' in r ? true : r.changes.length > 0));
+}
+async function flushSyncGeneratorChanges(results) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        return await flushSyncGeneratorChangesToDisk(results);
+    }
+    return await client_1.daemonClient.flushSyncGeneratorChangesToDisk(results.map((r) => r.generatorName));
+}
+async function collectAllRegisteredSyncGenerators(projectGraph, nxJson) {
+    if (!client_1.daemonClient.enabled()) {
+        return {
+            globalGenerators: [...collectRegisteredGlobalSyncGenerators()],
+            taskGenerators: [
+                ...collectEnabledTaskSyncGeneratorsFromProjectGraph(projectGraph, nxJson),
+            ],
+        };
+    }
+    return await client_1.daemonClient.getRegisteredSyncGenerators();
+}
+async function runSyncGenerator(tree, generatorSpecifier, projects) {
+    try {
+        perf_hooks_1.performance.mark(`run-sync-generator:${generatorSpecifier}:start`);
+        const { collection, generator } = (0, generate_1.parseGeneratorString)(generatorSpecifier);
+        const { implementationFactory } = (0, generator_utils_1.getGeneratorInformation)(collection, generator, workspace_root_1.workspaceRoot, projects);
+        const implementation = implementationFactory();
+        const result = await implementation(tree);
+        let callback;
+        let outOfSyncMessage;
+        if (result && typeof result === 'object') {
+            callback = result.callback;
+            outOfSyncMessage = result.outOfSyncMessage;
+        }
+        perf_hooks_1.performance.mark(`run-sync-generator:${generatorSpecifier}:end`);
+        perf_hooks_1.performance.measure(`run-sync-generator:${generatorSpecifier}`, `run-sync-generator:${generatorSpecifier}:start`, `run-sync-generator:${generatorSpecifier}:end`);
+        return {
+            changes: tree.listChanges(),
+            generatorName: generatorSpecifier,
+            callback,
+            outOfSyncMessage,
+        };
+    }
+    catch (e) {
+        return {
+            generatorName: generatorSpecifier,
+            error: toSerializableError(e),
+        };
+    }
+}
+function collectEnabledTaskSyncGeneratorsFromProjectGraph(projectGraph, nxJson) {
+    const taskSyncGenerators = new Set();
+    const disabledTaskSyncGenerators = new Set(nxJson.sync?.disabledTaskSyncGenerators ?? []);
+    for (const { data: { targets }, } of Object.values(projectGraph.nodes)) {
+        if (!targets) {
+            continue;
+        }
+        for (const target of Object.values(targets)) {
+            if (!target.syncGenerators?.length) {
+                continue;
+            }
+            for (const generator of target.syncGenerators) {
+                if (!disabledTaskSyncGenerators.has(generator) &&
+                    !taskSyncGenerators.has(generator)) {
+                    taskSyncGenerators.add(generator);
+                }
+            }
+        }
+    }
+    return taskSyncGenerators;
+}
+function collectEnabledTaskSyncGeneratorsFromTaskGraph(taskGraph, projectGraph, nxJson) {
+    const taskSyncGenerators = new Set();
+    const disabledTaskSyncGenerators = new Set(nxJson.sync?.disabledTaskSyncGenerators ?? []);
+    for (const { target } of Object.values(taskGraph.tasks)) {
+        const { syncGenerators } = projectGraph.nodes[target.project].data.targets[target.target];
+        if (!syncGenerators?.length) {
+            continue;
+        }
+        for (const generator of syncGenerators) {
+            if (!disabledTaskSyncGenerators.has(generator) &&
+                !taskSyncGenerators.has(generator)) {
+                taskSyncGenerators.add(generator);
+            }
+        }
+    }
+    return taskSyncGenerators;
+}
+function collectRegisteredGlobalSyncGenerators(nxJson = (0, nx_json_1.readNxJson)()) {
+    const globalSyncGenerators = new Set();
+    if (!nxJson.sync?.globalGenerators?.length) {
+        return globalSyncGenerators;
+    }
+    for (const generator of nxJson.sync.globalGenerators) {
+        globalSyncGenerators.add(generator);
+    }
+    return globalSyncGenerators;
+}
+function getSyncGeneratorSuccessResultsMessageLines(results) {
+    const messageLines = [];
+    for (const result of results) {
+        if ('error' in result) {
+            continue;
+        }
+        messageLines.push(`The ${chalk.bold(result.generatorName)} sync generator identified ${chalk.bold(result.changes.length)} file${result.changes.length === 1 ? '' : 's'} in the workspace that ${result.changes.length === 1 ? 'is' : 'are'} out of sync${result.outOfSyncMessage ? ':' : '.'}`);
+        if (result.outOfSyncMessage) {
+            messageLines.push(result.outOfSyncMessage);
+        }
+    }
+    return messageLines;
+}
+function getFailedSyncGeneratorsFixMessageLines(results, verbose, globalGeneratorSet = new Set()) {
+    const messageLines = [];
+    const globalGenerators = [];
+    const taskGenerators = [];
+    let isFirst = true;
+    for (const result of results) {
+        if ('error' in result) {
+            if (!isFirst) {
+                messageLines.push('');
+            }
+            isFirst = false;
+            messageLines.push(`The ${chalk.bold(result.generatorName)} sync generator reported the following error:`, '', errorToString(result.error, verbose));
+            if (globalGeneratorSet.has(result.generatorName)) {
+                globalGenerators.push(result.generatorName);
+            }
+            else {
+                taskGenerators.push(result.generatorName);
+            }
+        }
+    }
+    messageLines.push(...getFailedSyncGeneratorsMessageLines(taskGenerators, globalGenerators, verbose));
+    return messageLines;
+}
+function getFlushFailureMessageLines(result, verbose, globalGeneratorSet = new Set()) {
+    const messageLines = [];
+    const globalGenerators = [];
+    const taskGenerators = [];
+    let isFirst = true;
+    for (const failure of result.generatorFailures) {
+        if (!isFirst) {
+            messageLines.push('');
+        }
+        isFirst = false;
+        messageLines.push(`The ${chalk.bold(failure.generator)} sync generator failed to apply its changes with the following error:`, '', errorToString(failure.error, verbose));
+        if (globalGeneratorSet.has(failure.generator)) {
+            globalGenerators.push(failure.generator);
+        }
+        else {
+            taskGenerators.push(failure.generator);
+        }
+    }
+    messageLines.push(...getFailedSyncGeneratorsMessageLines(taskGenerators, globalGenerators, verbose));
+    if (result.generalFailure) {
+        if (messageLines.length > 0) {
+            messageLines.push('');
+            messageLines.push('Additionally, an unexpected error occurred:');
+        }
+        else {
+            messageLines.push('An unexpected error occurred:');
+        }
+        messageLines.push(...[
+            '',
+            result.generalFailure.message,
+            ...(verbose && !!result.generalFailure.stack
+                ? [`\n${result.generalFailure.stack}`]
+                : []),
+            '',
+            verbose
+                ? 'Please report the error at: https://github.com/nrwl/nx/issues/new/choose'
+                : 'Please run with `--verbose` and report the error at: https://github.com/nrwl/nx/issues/new/choose',
+        ]);
+    }
+    return messageLines;
+}
+function processSyncGeneratorResultErrors(results) {
+    let failedGeneratorsCount = 0;
+    for (const result of results) {
+        if ('error' in result) {
+            failedGeneratorsCount++;
+        }
+    }
+    const areAllResultsFailures = failedGeneratorsCount === results.length;
+    const anySyncGeneratorsFailed = failedGeneratorsCount > 0;
+    return {
+        failedGeneratorsCount,
+        areAllResultsFailures,
+        anySyncGeneratorsFailed,
+    };
+}
+async function runSyncGenerators(generators) {
+    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, 'running sync generators');
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+    const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    const results = [];
+    for (const generator of generators) {
+        const result = await runSyncGenerator(tree, generator, projects);
+        results.push(result);
+    }
+    return results;
+}
+async function flushSyncGeneratorChangesToDisk(results) {
+    perf_hooks_1.performance.mark('flush-sync-generator-changes-to-disk:start');
+    const createdFiles = [];
+    const updatedFiles = [];
+    const deletedFiles = [];
+    const generatorFailures = [];
+    for (const result of results) {
+        if ('error' in result) {
+            continue;
+        }
+        for (const change of result.changes) {
+            if (change.type === 'CREATE') {
+                createdFiles.push(change.path);
+            }
+            else if (change.type === 'UPDATE') {
+                updatedFiles.push(change.path);
+            }
+            else if (change.type === 'DELETE') {
+                deletedFiles.push(change.path);
+            }
+        }
+        try {
+            // Write changes to disk
+            (0, tree_1.flushChanges)(workspace_root_1.workspaceRoot, result.changes);
+            // Run the callback
+            if (result.callback) {
+                await result.callback();
+            }
+        }
+        catch (e) {
+            generatorFailures.push({
+                generator: result.generatorName,
+                error: toSerializableError(e),
+            });
+        }
+    }
+    try {
+        // Update the context files
+        await (0, workspace_context_1.updateContextWithChangedFiles)(workspace_root_1.workspaceRoot, createdFiles, updatedFiles, deletedFiles);
+        perf_hooks_1.performance.mark('flush-sync-generator-changes-to-disk:end');
+        perf_hooks_1.performance.measure('flush sync generator changes to disk', 'flush-sync-generator-changes-to-disk:start', 'flush-sync-generator-changes-to-disk:end');
+    }
+    catch (e) {
+        return {
+            generatorFailures,
+            generalFailure: toSerializableError(e),
+        };
+    }
+    return generatorFailures.length > 0
+        ? { generatorFailures }
+        : { success: true };
+}
+function getFailedSyncGeneratorsMessageLines(taskGenerators, globalGenerators, verbose) {
+    const messageLines = [];
+    if (taskGenerators.length + globalGenerators.length === 1) {
+        messageLines.push('', verbose
+            ? 'Please check the error above and address the issue.'
+            : 'Please check the error above and address the issue. You can provide the `--verbose` flag to get more details.');
+        if (taskGenerators.length === 1) {
+            messageLines.push(`If needed, you can disable the failing sync generator by setting \`sync.disabledTaskSyncGenerators: ["${taskGenerators[0]}"]\` in your \`nx.json\`.`);
+        }
+        else {
+            messageLines.push(`If needed, you can remove the failing global sync generator "${globalGenerators[0]}" from the \`sync.globalGenerators\` array in your \`nx.json\`.`);
+        }
+    }
+    else if (taskGenerators.length + globalGenerators.length > 1) {
+        messageLines.push('', verbose
+            ? 'Please check the errors above and address the issues.'
+            : 'Please check the errors above and address the issues. You can provide the `--verbose` flag to get more details.');
+        if (taskGenerators.length > 0) {
+            const generatorsString = taskGenerators.map((g) => `"${g}"`).join(', ');
+            messageLines.push(`If needed, you can disable the failing task sync generators by setting \`sync.disabledTaskSyncGenerators: [${generatorsString}]\` in your \`nx.json\`.`);
+        }
+        if (globalGenerators.length > 0) {
+            const lastGenerator = globalGenerators.pop();
+            const generatorsString = globalGenerators.length > 0
+                ? `${globalGenerators
+                    .map((g) => `"${g}"`)
+                    .join(', ')} and "${lastGenerator}"`
+                : `"${lastGenerator}"`;
+            messageLines.push(`If needed, you can remove the failing global sync generators ${generatorsString} from the \`sync.globalGenerators\` array in your \`nx.json\`.`);
+        }
+    }
+    return messageLines;
+}
+function errorToString(error, verbose) {
+    if (error.title) {
+        let message = `  ${chalk.red(error.title)}`;
+        if (error.bodyLines?.length) {
+            message += `
+
+  ${error.bodyLines
+                .map((bodyLine) => `${bodyLine.split('\n').join('\n  ')}`)
+                .join('\n  ')}`;
+            return message;
+        }
+    }
+    return `  ${chalk.red(error.message)}${verbose && error.stack ? '\n  ' + error.stack : ''}`;
+}
+function toSerializableError(error) {
+    return error instanceof SyncError
+        ? {
+            title: error.title,
+            bodyLines: error.bodyLines,
+            message: error.message,
+            stack: error.stack,
+        }
+        : { message: error.message, stack: error.stack };
+}

package/src/utils/task-history.d.ts

@@ -0,0 +1,17 @@
+import { NxTaskHistory, TaskRun, TaskTarget } from '../native';
+export declare class TaskHistory {
+    taskHistory: NxTaskHistory;
+    /**
+     * This function returns estimated timings per task
+     * @param targets
+     * @returns a map where key is task id (project:target:configuration), value is average time of historical runs
+     */
+    getEstimatedTaskTimings(targets: TaskTarget[]): Promise<Record<string, number>>;
+    getFlakyTasks(hashes: string[]): Promise<string[]>;
+    recordTaskRuns(taskRuns: TaskRun[]): Promise<void>;
+}
+/**
+ * This function returns the singleton instance of TaskHistory
+ * @returns singleton instance of TaskHistory, null if database is disabled or WASM is not enabled
+ */
+export declare function getTaskHistory(): TaskHistory | null;

package/src/utils/task-history.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskHistory = void 0;
+exports.getTaskHistory = getTaskHistory;
+const client_1 = require("../daemon/client/client");
+const is_on_daemon_1 = require("../daemon/is-on-daemon");
+const native_1 = require("../native");
+const db_connection_1 = require("./db-connection");
+class TaskHistory {
+    constructor() {
+        this.taskHistory = new native_1.NxTaskHistory((0, db_connection_1.getDbConnection)());
+    }
+    /**
+     * This function returns estimated timings per task
+     * @param targets
+     * @returns a map where key is task id (project:target:configuration), value is average time of historical runs
+     */
+    async getEstimatedTaskTimings(targets) {
+        if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+            return this.taskHistory.getEstimatedTaskTimings(targets);
+        }
+        return await client_1.daemonClient.getEstimatedTaskTimings(targets);
+    }
+    async getFlakyTasks(hashes) {
+        if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+            return this.taskHistory.getFlakyTasks(hashes);
+        }
+        return await client_1.daemonClient.getFlakyTasks(hashes);
+    }
+    async recordTaskRuns(taskRuns) {
+        if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+            return this.taskHistory.recordTaskRuns(taskRuns);
+        }
+        return client_1.daemonClient.recordTaskRuns(taskRuns);
+    }
+}
+exports.TaskHistory = TaskHistory;
+let taskHistory;
+/**
+ * This function returns the singleton instance of TaskHistory
+ * @returns singleton instance of TaskHistory, null if database is disabled or WASM is not enabled
+ */
+function getTaskHistory() {
+    if (process.env.NX_DISABLE_DB === 'true' || !native_1.IS_WASM) {
+        return null;
+    }
+    if (!taskHistory) {
+        taskHistory = new TaskHistory();
+    }
+    return taskHistory;
+}

package/src/utils/update-nxw.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '../generators/tree';
+export declare function updateNxw(tree: Tree): void;

package/src/utils/update-nxw.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateNxw = updateNxw;
+const add_nx_scripts_1 = require("../command-line/init/implementation/dot-nx/add-nx-scripts");
+const path_1 = require("../utils/path");
+function updateNxw(tree) {
+    const wrapperPath = (0, path_1.normalizePath)((0, add_nx_scripts_1.nxWrapperPath)());
+    if (tree.exists(wrapperPath)) {
+        tree.write(wrapperPath, (0, add_nx_scripts_1.getNxWrapperContents)());
+    }
+}

package/src/utils/versions.d.ts

@@ -0,0 +1 @@
+export declare const nxVersion: any;

package/src/utils/versions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;

package/src/utils/workspace-configuration-check.d.ts

@@ -0,0 +1 @@
+export declare function workspaceConfigurationCheck(): void;

package/src/utils/workspace-configuration-check.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceConfigurationCheck = workspaceConfigurationCheck;
+const workspace_root_1 = require("./workspace-root");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const output_1 = require("./output");
+const fileutils_1 = require("../utils/fileutils");
+//TODO: vsavkin remove after Nx 19
+function workspaceConfigurationCheck() {
+    if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'workspace.json'))) {
+        output_1.output.warn({
+            title: 'workspace.json is ignored',
+            bodyLines: [
+                'Nx no longer reads configuration from workspace.json.',
+                'Run "nx g @nx/workspace:fix-configuration" to split workspace.json into individual project.json files.',
+            ],
+        });
+        return;
+    }
+    if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'angular.json'))) {
+        const angularJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(workspace_root_1.workspaceRoot, 'angular.json'));
+        const v2Props = Object.values(angularJson.projects).find((p) => !!p.targets);
+        if (angularJson.version === 2 || v2Props) {
+            output_1.output.error({
+                title: 'angular.json format is incorrect',
+                bodyLines: [
+                    'Nx no longer supports the v2 format of angular.json.',
+                    'Run "nx g @nx/workspace:fix-configuration" to split angular.json into individual project.json files. (Recommended)',
+                    'If you want to preserve angular.json, run "nx g @nx/workspace:fix-configuration --reformat"',
+                ],
+            });
+            process.exit(1);
+        }
+    }
+}

package/src/utils/workspace-context.d.ts

@@ -0,0 +1,19 @@
+import type { NxWorkspaceFilesExternals } from '../native';
+export declare function setupWorkspaceContext(workspaceRoot: string): void;
+export declare function getNxWorkspaceFilesFromContext(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<import("../native").NxWorkspaceFiles>;
+/**
+ * Sync method to get files matching globs from workspace context.
+ * NOTE: This method will create the workspace context if it doesn't exist.
+ * It should only be used within Nx internal in code paths that **must** be sync.
+ * If used in an isolated plugin thread this will cause the workspace context
+ * to be recreated which is slow.
+ */
+export declare function globWithWorkspaceContextSync(workspaceRoot: string, globs: string[], exclude?: string[]): string[];
+export declare function globWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): Promise<string[]>;
+export declare function hashWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): Promise<string>;
+export declare function updateContextWithChangedFiles(workspaceRoot: string, createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<void>;
+export declare function updateFilesInContext(workspaceRoot: string, updatedFiles: string[], deletedFiles: string[]): Record<string, string>;
+export declare function getAllFileDataInContext(workspaceRoot: string): Promise<import("../native").FileData[]>;
+export declare function getFilesInDirectoryUsingContext(workspaceRoot: string, dir: string): Promise<string[]>;
+export declare function updateProjectFiles(projectRootMappings: Record<string, string>, rustReferences: NxWorkspaceFilesExternals, updatedFiles: Record<string, string>, deletedFiles: string[]): import("../native").UpdatedWorkspaceFiles;
+export declare function resetWorkspaceContext(): void;

package/src/utils/workspace-context.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupWorkspaceContext = setupWorkspaceContext;
+exports.getNxWorkspaceFilesFromContext = getNxWorkspaceFilesFromContext;
+exports.globWithWorkspaceContextSync = globWithWorkspaceContextSync;
+exports.globWithWorkspaceContext = globWithWorkspaceContext;
+exports.hashWithWorkspaceContext = hashWithWorkspaceContext;
+exports.updateContextWithChangedFiles = updateContextWithChangedFiles;
+exports.updateFilesInContext = updateFilesInContext;
+exports.getAllFileDataInContext = getAllFileDataInContext;
+exports.getFilesInDirectoryUsingContext = getFilesInDirectoryUsingContext;
+exports.updateProjectFiles = updateProjectFiles;
+exports.resetWorkspaceContext = resetWorkspaceContext;
+const perf_hooks_1 = require("perf_hooks");
+const cache_directory_1 = require("./cache-directory");
+const is_on_daemon_1 = require("../daemon/is-on-daemon");
+const client_1 = require("../daemon/client/client");
+let workspaceContext;
+function setupWorkspaceContext(workspaceRoot) {
+    const { WorkspaceContext } = require('../native');
+    perf_hooks_1.performance.mark('workspace-context');
+    workspaceContext = new WorkspaceContext(workspaceRoot, (0, cache_directory_1.workspaceDataDirectoryForWorkspace)(workspaceRoot));
+    perf_hooks_1.performance.mark('workspace-context:end');
+    perf_hooks_1.performance.measure('workspace context init', 'workspace-context', 'workspace-context:end');
+}
+async function getNxWorkspaceFilesFromContext(workspaceRoot, projectRootMap) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.getWorkspaceFiles(projectRootMap);
+    }
+    return client_1.daemonClient.getWorkspaceFiles(projectRootMap);
+}
+/**
+ * Sync method to get files matching globs from workspace context.
+ * NOTE: This method will create the workspace context if it doesn't exist.
+ * It should only be used within Nx internal in code paths that **must** be sync.
+ * If used in an isolated plugin thread this will cause the workspace context
+ * to be recreated which is slow.
+ */
+function globWithWorkspaceContextSync(workspaceRoot, globs, exclude) {
+    ensureContextAvailable(workspaceRoot);
+    return workspaceContext.glob(globs, exclude);
+}
+async function globWithWorkspaceContext(workspaceRoot, globs, exclude) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.glob(globs, exclude);
+    }
+    else {
+        return client_1.daemonClient.glob(globs, exclude);
+    }
+}
+async function hashWithWorkspaceContext(workspaceRoot, globs, exclude) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.hashFilesMatchingGlob(globs, exclude);
+    }
+    return client_1.daemonClient.hashGlob(globs, exclude);
+}
+async function updateContextWithChangedFiles(workspaceRoot, createdFiles, updatedFiles, deletedFiles) {
+    if (!client_1.daemonClient.enabled()) {
+        updateFilesInContext(workspaceRoot, [...createdFiles, ...updatedFiles], deletedFiles);
+    }
+    else if ((0, is_on_daemon_1.isOnDaemon)()) {
+        // make sure to only import this when running on the daemon
+        const { addUpdatedAndDeletedFiles } = await Promise.resolve().then(() => require('../daemon/server/project-graph-incremental-recomputation'));
+        // update files for the incremental graph recomputation on the daemon
+        addUpdatedAndDeletedFiles(createdFiles, updatedFiles, deletedFiles);
+    }
+    else {
+        // daemon is enabled but we are not running on it, ask the daemon to update the context
+        await client_1.daemonClient.updateWorkspaceContext(createdFiles, updatedFiles, deletedFiles);
+    }
+}
+function updateFilesInContext(workspaceRoot, updatedFiles, deletedFiles) {
+    ensureContextAvailable(workspaceRoot);
+    return workspaceContext?.incrementalUpdate(updatedFiles, deletedFiles);
+}
+async function getAllFileDataInContext(workspaceRoot) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.allFileData();
+    }
+    return client_1.daemonClient.getWorkspaceContextFileData();
+}
+async function getFilesInDirectoryUsingContext(workspaceRoot, dir) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.getFilesInDirectory(dir);
+    }
+    return client_1.daemonClient.getFilesInDirectory(dir);
+}
+function updateProjectFiles(projectRootMappings, rustReferences, updatedFiles, deletedFiles) {
+    return workspaceContext?.updateProjectFiles(projectRootMappings, rustReferences.projectFiles, rustReferences.globalFiles, updatedFiles, deletedFiles);
+}
+function ensureContextAvailable(workspaceRoot) {
+    if (!workspaceContext || workspaceContext?.workspaceRoot !== workspaceRoot) {
+        setupWorkspaceContext(workspaceRoot);
+    }
+}
+function resetWorkspaceContext() {
+    workspaceContext = undefined;
+}

package/src/utils/workspace-root.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The root of the workspace
+ */
+export declare let workspaceRoot: string;
+export declare function setWorkspaceRoot(root: string): void;
+export declare function workspaceRootInner(dir: string, candidateRoot: string | null): string;

package/src/utils/workspace-root.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceRoot = void 0;
+exports.setWorkspaceRoot = setWorkspaceRoot;
+exports.workspaceRootInner = workspaceRootInner;
+const path = require("path");
+const fileutils_1 = require("./fileutils");
+/**
+ * The root of the workspace
+ */
+exports.workspaceRoot = workspaceRootInner(process.cwd(), process.cwd());
+// Required for integration tests in projects which depend on Nx at runtime, such as lerna and angular-eslint
+function setWorkspaceRoot(root) {
+    exports.workspaceRoot = root;
+}
+function workspaceRootInner(dir, candidateRoot) {
+    if (process.env.NX_WORKSPACE_ROOT_PATH)
+        return process.env.NX_WORKSPACE_ROOT_PATH;
+    if (path.dirname(dir) === dir)
+        return candidateRoot;
+    const matches = [
+        path.join(dir, 'nx.json'),
+        path.join(dir, 'nx'),
+        path.join(dir, 'nx.bat'),
+    ];
+    if (matches.some((x) => (0, fileutils_1.fileExists)(x))) {
+        return dir;
+        // This handles the case where we have a workspace which uses npm / yarn / pnpm
+        // workspaces, and has a project which contains Nx in its dependency tree.
+        // e.g. packages/my-lib/package.json contains @nx/devkit, which references Nx and is
+        // thus located in //packages/my-lib/node_modules/nx/package.json
+    }
+    else if ((0, fileutils_1.fileExists)(path.join(dir, 'node_modules', 'nx', 'package.json'))) {
+        return workspaceRootInner(path.dirname(dir), dir);
+    }
+    else {
+        return workspaceRootInner(path.dirname(dir), candidateRoot);
+    }
+}

package/tasks-runners/default.d.ts

@@ -0,0 +1 @@
+export { defaultTasksRunner as default } from '../src/tasks-runner/default-tasks-runner';

package/tasks-runners/default.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var default_tasks_runner_1 = require("../src/tasks-runner/default-tasks-runner");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return default_tasks_runner_1.defaultTasksRunner; } });