@ohos-ports/nx 19.8.4-beta.0

package/src/tasks-runner/tasks-schedule.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TasksSchedule = void 0;
+const utils_1 = require("./utils");
+const project_graph_utils_1 = require("../utils/project-graph-utils");
+const operators_1 = require("../project-graph/operators");
+const task_history_1 = require("../utils/task-history");
+class TasksSchedule {
+    constructor(projectGraph, taskGraph, options) {
+        this.projectGraph = projectGraph;
+        this.taskGraph = taskGraph;
+        this.options = options;
+        this.notScheduledTaskGraph = this.taskGraph;
+        this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
+        this.reverseProjectGraph = (0, operators_1.reverse)(this.projectGraph);
+        this.taskHistory = (0, task_history_1.getTaskHistory)();
+        this.scheduledBatches = [];
+        this.scheduledTasks = [];
+        this.runningTasks = new Set();
+        this.completedTasks = new Set();
+        this.scheduleRequestsExecutionChain = Promise.resolve();
+        this.estimatedTaskTimings = {};
+        this.projectDependencies = {};
+    }
+    async init() {
+        if (this.taskHistory) {
+            this.estimatedTaskTimings =
+                await this.taskHistory.getEstimatedTaskTimings(Object.values(this.taskGraph.tasks).map((t) => t.target));
+        }
+        for (const project of Object.values(this.taskGraph.tasks).map((t) => t.target.project)) {
+            this.projectDependencies[project] ??= (0, project_graph_utils_1.findAllProjectNodeDependencies)(project, this.reverseProjectGraph).length;
+        }
+    }
+    async scheduleNextTasks() {
+        this.scheduleRequestsExecutionChain =
+            this.scheduleRequestsExecutionChain.then(() => this.scheduleTasks());
+        await this.scheduleRequestsExecutionChain;
+    }
+    hasTasks() {
+        return (this.scheduledBatches.length +
+            this.scheduledTasks.length +
+            Object.keys(this.notScheduledTaskGraph.tasks).length !==
+            0);
+    }
+    complete(taskIds) {
+        for (const taskId of taskIds) {
+            this.completedTasks.add(taskId);
+            this.runningTasks.delete(taskId);
+        }
+        this.notScheduledTaskGraph = (0, utils_1.removeTasksFromTaskGraph)(this.notScheduledTaskGraph, taskIds);
+    }
+    getAllScheduledTasks() {
+        return {
+            scheduledTasks: this.scheduledTasks,
+            scheduledBatches: this.scheduledBatches,
+        };
+    }
+    nextTask() {
+        if (this.scheduledTasks.length > 0) {
+            return this.taskGraph.tasks[this.scheduledTasks.shift()];
+        }
+        else {
+            return null;
+        }
+    }
+    nextBatch() {
+        return this.scheduledBatches.length > 0
+            ? this.scheduledBatches.shift()
+            : null;
+    }
+    async scheduleTasks() {
+        if (this.options.batch || process.env.NX_BATCH_MODE === 'true') {
+            await this.scheduleBatches();
+        }
+        for (let root of this.notScheduledTaskGraph.roots) {
+            if (this.canBeScheduled(root)) {
+                await this.scheduleTask(root);
+            }
+        }
+    }
+    async scheduleTask(taskId) {
+        this.notScheduledTaskGraph = (0, utils_1.removeTasksFromTaskGraph)(this.notScheduledTaskGraph, [taskId]);
+        this.scheduledTasks = this.scheduledTasks
+            .concat(taskId)
+            // NOTE: sort task by most dependent on first
+            .sort((taskId1, taskId2) => {
+            // First compare the length of task dependencies.
+            const taskDifference = this.reverseTaskDeps[taskId2].length -
+                this.reverseTaskDeps[taskId1].length;
+            if (taskDifference !== 0) {
+                return taskDifference;
+            }
+            // Tie-breaker for tasks with equal number of task dependencies.
+            // Most likely tasks with no dependencies such as test
+            const project1 = this.taskGraph.tasks[taskId1].target.project;
+            const project2 = this.taskGraph.tasks[taskId2].target.project;
+            const project1NodeDependencies = this.projectDependencies[project1];
+            const project2NodeDependencies = this.projectDependencies[project2];
+            const dependenciesDiff = project2NodeDependencies - project1NodeDependencies;
+            if (dependenciesDiff !== 0) {
+                return dependenciesDiff;
+            }
+            const task1Timing = this.estimatedTaskTimings[taskId1];
+            if (!task1Timing) {
+                // if no timing or 0, put task1 at beginning
+                return -1;
+            }
+            const task2Timing = this.estimatedTaskTimings[taskId2];
+            if (!task2Timing) {
+                // if no timing or 0, put task2 at beginning
+                return 1;
+            }
+            return task2Timing - task1Timing;
+        });
+        this.runningTasks.add(taskId);
+    }
+    async scheduleBatches() {
+        const batchMap = {};
+        for (const root of this.notScheduledTaskGraph.roots) {
+            const rootTask = this.notScheduledTaskGraph.tasks[root];
+            const executorName = (0, utils_1.getExecutorNameForTask)(rootTask, this.projectGraph);
+            await this.processTaskForBatches(batchMap, rootTask, executorName, true);
+        }
+        for (const [executorName, taskGraph] of Object.entries(batchMap)) {
+            this.scheduleBatch({ executorName, taskGraph });
+        }
+    }
+    scheduleBatch({ executorName, taskGraph }) {
+        // Create a new task graph without the tasks that are being scheduled as part of this batch
+        this.notScheduledTaskGraph = (0, utils_1.removeTasksFromTaskGraph)(this.notScheduledTaskGraph, Object.keys(taskGraph.tasks));
+        this.scheduledBatches.push({ executorName, taskGraph });
+    }
+    async processTaskForBatches(batches, task, rootExecutorName, isRoot) {
+        if (!this.canBatchTaskBeScheduled(task, batches[rootExecutorName])) {
+            return;
+        }
+        const { batchImplementationFactory } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+        const executorName = (0, utils_1.getExecutorNameForTask)(task, this.projectGraph);
+        if (rootExecutorName !== executorName) {
+            return;
+        }
+        if (!batchImplementationFactory) {
+            return;
+        }
+        const batch = (batches[rootExecutorName] =
+            batches[rootExecutorName] ??
+                {
+                    tasks: {},
+                    dependencies: {},
+                    roots: [],
+                });
+        batch.tasks[task.id] = task;
+        batch.dependencies[task.id] =
+            this.notScheduledTaskGraph.dependencies[task.id];
+        if (isRoot) {
+            batch.roots.push(task.id);
+        }
+        for (const dep of this.reverseTaskDeps[task.id]) {
+            const depTask = this.taskGraph.tasks[dep];
+            await this.processTaskForBatches(batches, depTask, rootExecutorName, false);
+        }
+    }
+    canBatchTaskBeScheduled(task, batchTaskGraph) {
+        // task self needs to have parallelism true
+        // all deps have either completed or belong to the same batch
+        return (task.parallelism === true &&
+            this.taskGraph.dependencies[task.id].every((id) => this.completedTasks.has(id) || !!batchTaskGraph?.tasks[id]));
+    }
+    canBeScheduled(taskId) {
+        const hasDependenciesCompleted = this.taskGraph.dependencies[taskId].every((id) => this.completedTasks.has(id));
+        // if dependencies have not completed, cannot schedule
+        if (!hasDependenciesCompleted) {
+            return false;
+        }
+        // if there are no running tasks, can schedule anything
+        if (this.runningTasks.size === 0) {
+            return true;
+        }
+        const runningTasksNotSupportParallelism = Array.from(this.runningTasks).some((taskId) => {
+            return this.taskGraph.tasks[taskId].parallelism === false;
+        });
+        if (runningTasksNotSupportParallelism) {
+            // if any running tasks do not support parallelism, no other tasks can be scheduled
+            return false;
+        }
+        else {
+            // if all running tasks support parallelism, can only schedule task with parallelism
+            return this.taskGraph.tasks[taskId].parallelism === true;
+        }
+    }
+}
+exports.TasksSchedule = TasksSchedule;

package/src/tasks-runner/utils.d.ts

@@ -0,0 +1,57 @@
+import { Task, TaskGraph } from '../config/task-graph';
+import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { TargetConfiguration, TargetDependencyConfig } from '../config/workspace-json-project-json';
+import { CustomHasher, ExecutorConfig } from '../config/misc-interfaces';
+export type NormalizedTargetDependencyConfig = TargetDependencyConfig & {
+    projects: string[];
+};
+export declare function getDependencyConfigs({ project, target }: {
+    project: string;
+    target: string;
+}, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, projectGraph: ProjectGraph, allTargetNames: string[]): NormalizedTargetDependencyConfig[] | undefined;
+export declare function normalizeDependencyConfigDefinition(definition: string | TargetDependencyConfig, currentProject: string, graph: ProjectGraph, allTargetNames: string[]): NormalizedTargetDependencyConfig[];
+export declare function normalizeDependencyConfigProjects(dependencyConfig: TargetDependencyConfig, currentProject: string, graph: ProjectGraph): NormalizedTargetDependencyConfig;
+export declare function expandDependencyConfigSyntaxSugar(dependencyConfigString: string | TargetDependencyConfig, graph: ProjectGraph): TargetDependencyConfig;
+export declare function expandWildcardTargetConfiguration(dependencyConfig: NormalizedTargetDependencyConfig, allTargetNames: string[]): NormalizedTargetDependencyConfig[];
+export declare function readProjectAndTargetFromTargetString(targetString: string, projects: Record<string, ProjectGraphProjectNode>): {
+    projects?: string[];
+    target: string;
+};
+export declare function getOutputs(p: Record<string, ProjectGraphProjectNode>, target: Task['target'], overrides: Task['overrides']): string[];
+export declare function normalizeTargetDependencyWithStringProjects(dependencyConfig: TargetDependencyConfig): Omit<TargetDependencyConfig, 'projects'> & {
+    projects: string[];
+};
+export declare function validateOutputs(outputs: string[]): void;
+export declare function transformLegacyOutputs(projectRoot: string, outputs: string[]): string[];
+/**
+ * @deprecated Pass the target and overrides instead. This will be removed in v20.
+ */
+export declare function getOutputsForTargetAndConfiguration(task: Task, node: ProjectGraphProjectNode): string[];
+export declare function getOutputsForTargetAndConfiguration(target: Task['target'] | Task, overrides: Task['overrides'] | ProjectGraphProjectNode, node: ProjectGraphProjectNode): string[];
+export declare function interpolate(template: string, data: any): string;
+export declare function getTargetConfigurationForTask(task: Task, projectGraph: ProjectGraph): TargetConfiguration | undefined;
+export declare function getExecutorNameForTask(task: Task, projectGraph: ProjectGraph): string;
+export declare function getExecutorForTask(task: Task, projectGraph: ProjectGraph): ExecutorConfig & {
+    isNgCompat: boolean;
+    isNxExecutor: boolean;
+};
+export declare function getCustomHasher(task: Task, projectGraph: ProjectGraph): CustomHasher | null;
+export declare function removeTasksFromTaskGraph(graph: TaskGraph, ids: string[]): TaskGraph;
+export declare function removeIdsFromGraph<T>(graph: {
+    roots: string[];
+    dependencies: Record<string, string[]>;
+}, ids: string[], mapWithIds: Record<string, T>): {
+    mapWithIds: Record<string, T>;
+    roots: string[];
+    dependencies: Record<string, string[]>;
+};
+export declare function calculateReverseDeps(taskGraph: TaskGraph): Record<string, string[]>;
+export declare function getCliPath(): string;
+export declare function getPrintableCommandArgsForTask(task: Task): string[];
+export declare function getSerializedArgsForTask(task: Task, isVerbose: boolean): string[];
+export declare function shouldStreamOutput(task: Task, initiatingProject: string | null): boolean;
+export declare function isCacheableTask(task: Task, options: {
+    cacheableOperations?: string[] | null;
+    cacheableTargets?: string[] | null;
+}): boolean;
+export declare function unparse(options: Object): string[];

package/src/tasks-runner/utils.js

@@ -0,0 +1,392 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDependencyConfigs = getDependencyConfigs;
+exports.normalizeDependencyConfigDefinition = normalizeDependencyConfigDefinition;
+exports.normalizeDependencyConfigProjects = normalizeDependencyConfigProjects;
+exports.expandDependencyConfigSyntaxSugar = expandDependencyConfigSyntaxSugar;
+exports.expandWildcardTargetConfiguration = expandWildcardTargetConfiguration;
+exports.readProjectAndTargetFromTargetString = readProjectAndTargetFromTargetString;
+exports.getOutputs = getOutputs;
+exports.normalizeTargetDependencyWithStringProjects = normalizeTargetDependencyWithStringProjects;
+exports.validateOutputs = validateOutputs;
+exports.transformLegacyOutputs = transformLegacyOutputs;
+exports.getOutputsForTargetAndConfiguration = getOutputsForTargetAndConfiguration;
+exports.interpolate = interpolate;
+exports.getTargetConfigurationForTask = getTargetConfigurationForTask;
+exports.getExecutorNameForTask = getExecutorNameForTask;
+exports.getExecutorForTask = getExecutorForTask;
+exports.getCustomHasher = getCustomHasher;
+exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
+exports.removeIdsFromGraph = removeIdsFromGraph;
+exports.calculateReverseDeps = calculateReverseDeps;
+exports.getCliPath = getCliPath;
+exports.getPrintableCommandArgsForTask = getPrintableCommandArgsForTask;
+exports.getSerializedArgsForTask = getSerializedArgsForTask;
+exports.shouldStreamOutput = shouldStreamOutput;
+exports.isCacheableTask = isCacheableTask;
+exports.unparse = unparse;
+const path_1 = require("path");
+const posix_1 = require("path/posix");
+const workspace_root_1 = require("../utils/workspace-root");
+const path_2 = require("../utils/path");
+const fileutils_1 = require("../utils/fileutils");
+const serialize_overrides_into_command_line_1 = require("../utils/serialize-overrides-into-command-line");
+const split_target_1 = require("../utils/split-target");
+const executor_utils_1 = require("../command-line/run/executor-utils");
+const project_graph_1 = require("../project-graph/project-graph");
+const find_matching_projects_1 = require("../utils/find-matching-projects");
+const minimatch_1 = require("minimatch");
+const globs_1 = require("../utils/globs");
+const native_1 = require("../native");
+function getDependencyConfigs({ project, target }, extraTargetDependencies, projectGraph, allTargetNames) {
+    const dependencyConfigs = (projectGraph.nodes[project].data?.targets[target]?.dependsOn ??
+        // This is passed into `run-command` from programmatic invocations
+        extraTargetDependencies[target] ??
+        []).flatMap((config) => normalizeDependencyConfigDefinition(config, project, projectGraph, allTargetNames));
+    return dependencyConfigs;
+}
+function normalizeDependencyConfigDefinition(definition, currentProject, graph, allTargetNames) {
+    return expandWildcardTargetConfiguration(normalizeDependencyConfigProjects(expandDependencyConfigSyntaxSugar(definition, graph), currentProject, graph), allTargetNames);
+}
+function normalizeDependencyConfigProjects(dependencyConfig, currentProject, graph) {
+    const noStringConfig = normalizeTargetDependencyWithStringProjects(dependencyConfig);
+    if (noStringConfig.projects) {
+        dependencyConfig.projects = (0, find_matching_projects_1.findMatchingProjects)(noStringConfig.projects, graph.nodes);
+    }
+    else if (!noStringConfig.dependencies) {
+        dependencyConfig.projects = [currentProject];
+    }
+    return dependencyConfig;
+}
+function expandDependencyConfigSyntaxSugar(dependencyConfigString, graph) {
+    if (typeof dependencyConfigString !== 'string') {
+        return dependencyConfigString;
+    }
+    const [dependencies, targetString] = dependencyConfigString.startsWith('^')
+        ? [true, dependencyConfigString.substring(1)]
+        : [false, dependencyConfigString];
+    // Support for `project:target` syntax doesn't make sense for
+    // dependencies, so we only support `target` syntax for dependencies.
+    if (dependencies) {
+        return {
+            target: targetString,
+            dependencies: true,
+        };
+    }
+    const { projects, target } = readProjectAndTargetFromTargetString(targetString, graph.nodes);
+    return projects ? { projects, target } : { target };
+}
+// Weakmap let's the cache get cleared by garbage collector if allTargetNames is no longer used
+const patternResultCache = new WeakMap();
+function findMatchingTargets(pattern, allTargetNames) {
+    let cache = patternResultCache.get(allTargetNames);
+    if (!cache) {
+        cache = new Map();
+        patternResultCache.set(allTargetNames, cache);
+    }
+    const cachedResult = cache.get(pattern);
+    if (cachedResult) {
+        return cachedResult;
+    }
+    const matcher = minimatch_1.minimatch.filter(pattern);
+    const matchingTargets = allTargetNames.filter((t) => matcher(t));
+    cache.set(pattern, matchingTargets);
+    return matchingTargets;
+}
+function expandWildcardTargetConfiguration(dependencyConfig, allTargetNames) {
+    if (!(0, globs_1.isGlobPattern)(dependencyConfig.target)) {
+        return [dependencyConfig];
+    }
+    const matchingTargets = findMatchingTargets(dependencyConfig.target, allTargetNames);
+    return matchingTargets.map((t) => ({
+        target: t,
+        projects: dependencyConfig.projects,
+        dependencies: dependencyConfig.dependencies,
+    }));
+}
+function readProjectAndTargetFromTargetString(targetString, projects) {
+    // Support for both `project:target` and `target:with:colons` syntax
+    const [maybeProject, ...segments] = (0, split_target_1.splitByColons)(targetString);
+    if (!segments.length) {
+        // if no additional segments are provided, then the string references
+        // a target of the same project
+        return { target: maybeProject };
+    }
+    else if (maybeProject in projects) {
+        // Only the first segment could be a project. If it is, the rest is a target.
+        // If its not, then the whole targetString was a target with colons in its name.
+        return { projects: [maybeProject], target: segments.join(':') };
+    }
+    else {
+        // If the first segment is a project, then we have a specific project. Otherwise, we don't.
+        return { target: targetString };
+    }
+}
+function getOutputs(p, target, overrides) {
+    return getOutputsForTargetAndConfiguration(target, overrides, p[target.project]);
+}
+function normalizeTargetDependencyWithStringProjects(dependencyConfig) {
+    if (typeof dependencyConfig.projects === 'string') {
+        /** LERNA SUPPORT START - Remove in v20 */
+        // Lerna uses `dependencies` in `prepNxOptions`, so we need to maintain
+        // support for it until lerna can be updated to use the syntax.
+        //
+        // This should have been removed in v17, but the updates to lerna had not
+        // been made yet.
+        //
+        // TODO(@agentender): Remove this part in v20
+        if (dependencyConfig.projects === 'self') {
+            delete dependencyConfig.projects;
+        }
+        else if (dependencyConfig.projects === 'dependencies') {
+            dependencyConfig.dependencies = true;
+            delete dependencyConfig.projects;
+            /** LERNA SUPPORT END - Remove in v20 */
+        }
+        else {
+            dependencyConfig.projects = [dependencyConfig.projects];
+        }
+    }
+    return dependencyConfig;
+}
+class InvalidOutputsError extends Error {
+    constructor(outputs, invalidOutputs) {
+        super(InvalidOutputsError.createMessage(invalidOutputs));
+        this.outputs = outputs;
+        this.invalidOutputs = invalidOutputs;
+    }
+    static createMessage(invalidOutputs) {
+        const invalidOutputsList = '\n - ' + Array.from(invalidOutputs).join('\n - ');
+        return `The following outputs are invalid:${invalidOutputsList}\nPlease run "nx repair" to repair your configuration`;
+    }
+}
+function assertOutputsAreValidType(outputs) {
+    if (!Array.isArray(outputs)) {
+        throw new Error("The 'outputs' field must be an array");
+    }
+    const typesArray = [];
+    let hasInvalidType = false;
+    for (const output of outputs) {
+        if (typeof output !== 'string') {
+            hasInvalidType = true;
+        }
+        typesArray.push(typeof output);
+    }
+    if (hasInvalidType) {
+        throw new Error(`The 'outputs' field must contain only strings, but received types: [${typesArray.join(', ')}]`);
+    }
+}
+function validateOutputs(outputs) {
+    assertOutputsAreValidType(outputs);
+    (0, native_1.validateOutputs)(outputs);
+}
+function transformLegacyOutputs(projectRoot, outputs) {
+    const transformableOutputs = new Set((0, native_1.getTransformableOutputs)(outputs));
+    if (transformableOutputs.size === 0) {
+        return outputs;
+    }
+    return outputs.map((output) => {
+        if (!transformableOutputs.has(output)) {
+            return output;
+        }
+        let [isNegated, outputPath] = output.startsWith('!')
+            ? [true, output.substring(1)]
+            : [false, output];
+        const relativePath = (0, fileutils_1.isRelativePath)(outputPath)
+            ? output
+            : (0, path_1.relative)(projectRoot, outputPath);
+        const isWithinProject = !relativePath.startsWith('..');
+        return ((isNegated ? '!' : '') +
+            (0, path_2.joinPathFragments)(isWithinProject ? '{projectRoot}' : '{workspaceRoot}', isWithinProject ? relativePath : outputPath));
+    });
+}
+/**
+ * Returns the list of outputs that will be cached.
+ */
+function getOutputsForTargetAndConfiguration(taskTargetOrTask, overridesOrNode, node) {
+    const taskTarget = 'id' in taskTargetOrTask ? taskTargetOrTask.target : taskTargetOrTask;
+    const overrides = 'id' in taskTargetOrTask ? taskTargetOrTask.overrides : overridesOrNode;
+    node = 'id' in taskTargetOrTask ? overridesOrNode : node;
+    const { target, configuration } = taskTarget;
+    const targetConfiguration = node.data.targets[target];
+    const options = {
+        ...targetConfiguration?.options,
+        ...targetConfiguration?.configurations?.[configuration],
+        ...overrides,
+    };
+    if (targetConfiguration?.outputs) {
+        validateOutputs(targetConfiguration.outputs);
+        const result = new Set();
+        for (const output of targetConfiguration.outputs) {
+            const interpolatedOutput = interpolate(output, {
+                projectRoot: node.data.root,
+                projectName: node.name,
+                project: { ...node.data, name: node.name }, // this is legacy
+                options,
+            });
+            if (!!interpolatedOutput &&
+                !interpolatedOutput.match(/{(projectRoot|workspaceRoot|(options.*))}/)) {
+                result.add(interpolatedOutput);
+            }
+        }
+        return Array.from(result);
+    }
+    // Keep backwards compatibility in case `outputs` doesn't exist
+    if (options.outputPath) {
+        return Array.isArray(options.outputPath)
+            ? options.outputPath
+            : [options.outputPath];
+    }
+    else if (target === 'build' || target === 'prepare') {
+        return [
+            `dist/${node.data.root}`,
+            `${node.data.root}/dist`,
+            `${node.data.root}/build`,
+            `${node.data.root}/public`,
+        ];
+    }
+    else {
+        return [];
+    }
+}
+/**
+ * Matches portions of a string which need to be interpolated.
+ * Matches anything within curly braces, excluding the braces.
+ */
+const replacementRegex = /{([\s\S]+?)}/g;
+function interpolate(template, data) {
+    // Path is absolute or doesn't need interpolation
+    if (template.startsWith('/') || !replacementRegex.test(template)) {
+        return template;
+    }
+    if (template.includes('{workspaceRoot}', 1)) {
+        throw new Error(`Output '${template}' is invalid. {workspaceRoot} can only be used at the beginning of the expression.`);
+    }
+    if (data.projectRoot == '.' && template.includes('{projectRoot}', 1)) {
+        throw new Error(`Output '${template}' is invalid. When {projectRoot} is '.', it can only be used at the beginning of the expression.`);
+    }
+    const parts = template.split('/').map((s) => _interpolate(s, data));
+    return (0, posix_1.join)(...parts).replace('{workspaceRoot}/', '');
+}
+function _interpolate(template, data) {
+    let res = template;
+    if (data.projectRoot == '.') {
+        res = res.replace('{projectRoot}', '');
+    }
+    return res.replace(replacementRegex, (match) => {
+        let value = data;
+        let path = match.slice(1, -1).trim().split('.');
+        for (let idx = 0; idx < path.length; idx++) {
+            if (!value[path[idx]]) {
+                return match;
+            }
+            value = value[path[idx]];
+        }
+        return value;
+    });
+}
+function getTargetConfigurationForTask(task, projectGraph) {
+    const project = projectGraph.nodes[task.target.project].data;
+    return project.targets[task.target.target];
+}
+function getExecutorNameForTask(task, projectGraph) {
+    return getTargetConfigurationForTask(task, projectGraph)?.executor;
+}
+function getExecutorForTask(task, projectGraph) {
+    const executor = getExecutorNameForTask(task, projectGraph);
+    const [nodeModule, executorName] = executor.split(':');
+    return (0, executor_utils_1.getExecutorInformation)(nodeModule, executorName, workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects);
+}
+function getCustomHasher(task, projectGraph) {
+    const factory = getExecutorForTask(task, projectGraph).hasherFactory;
+    return factory ? factory() : null;
+}
+function removeTasksFromTaskGraph(graph, ids) {
+    const newGraph = removeIdsFromGraph(graph, ids, graph.tasks);
+    return {
+        dependencies: newGraph.dependencies,
+        roots: newGraph.roots,
+        tasks: newGraph.mapWithIds,
+    };
+}
+function removeIdsFromGraph(graph, ids, mapWithIds) {
+    const filteredMapWithIds = {};
+    const dependencies = {};
+    const removedSet = new Set(ids);
+    for (let id of Object.keys(mapWithIds)) {
+        if (!removedSet.has(id)) {
+            filteredMapWithIds[id] = mapWithIds[id];
+            dependencies[id] = graph.dependencies[id].filter((depId) => !removedSet.has(depId));
+        }
+    }
+    return {
+        mapWithIds: filteredMapWithIds,
+        dependencies: dependencies,
+        roots: Object.keys(dependencies).filter((k) => dependencies[k].length === 0),
+    };
+}
+function calculateReverseDeps(taskGraph) {
+    const reverseTaskDeps = {};
+    Object.keys(taskGraph.tasks).forEach((t) => {
+        reverseTaskDeps[t] = [];
+    });
+    Object.keys(taskGraph.dependencies).forEach((taskId) => {
+        taskGraph.dependencies[taskId].forEach((d) => {
+            reverseTaskDeps[d].push(taskId);
+        });
+    });
+    return reverseTaskDeps;
+}
+function getCliPath() {
+    return require.resolve(`../../bin/run-executor.js`);
+}
+function getPrintableCommandArgsForTask(task) {
+    const args = task.overrides['__overrides_unparsed__'];
+    const target = task.target.target.includes(':')
+        ? `"${task.target.target}"`
+        : task.target.target;
+    const config = task.target.configuration
+        ? `:${task.target.configuration}`
+        : '';
+    return ['run', `${task.target.project}:${target}${config}`, ...args];
+}
+function getSerializedArgsForTask(task, isVerbose) {
+    return [
+        JSON.stringify({
+            targetDescription: task.target,
+            overrides: task.overrides,
+            isVerbose: isVerbose,
+        }),
+    ];
+}
+function shouldStreamOutput(task, initiatingProject) {
+    if (process.env.NX_STREAM_OUTPUT === 'true')
+        return true;
+    if (longRunningTask(task))
+        return true;
+    if (task.target.project === initiatingProject)
+        return true;
+    return false;
+}
+function isCacheableTask(task, options) {
+    if (task.cache !== undefined && !longRunningTask(task)) {
+        return task.cache;
+    }
+    const cacheable = options.cacheableOperations || options.cacheableTargets;
+    return (cacheable &&
+        cacheable.indexOf(task.target.target) > -1 &&
+        !longRunningTask(task));
+}
+function longRunningTask(task) {
+    const t = task.target.target;
+    return ((!!task.overrides['watch'] && task.overrides['watch'] !== 'false') ||
+        t.endsWith(':watch') ||
+        t.endsWith('-watch') ||
+        t === 'serve' ||
+        t === 'dev' ||
+        t === 'start');
+}
+// TODO: vsavkin remove when nx-cloud doesn't depend on it
+function unparse(options) {
+    return (0, serialize_overrides_into_command_line_1.serializeOverridesIntoCommandLine)(options);
+}