nx 20.0.0-beta.4 → 20.0.0-beta.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "20.0.0-beta.4",
+  "version": "20.0.0-beta.5",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -65,8 +65,7 @@
     "yargs": "^17.6.2",
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
-    "ora": "5.3.0",
-    "@nrwl/tao": "20.0.0-beta.4"
+    "ora": "5.3.0"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -81,16 +80,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "20.0.0-beta.4",
-    "@nx/nx-darwin-arm64": "20.0.0-beta.4",
-    "@nx/nx-linux-x64-gnu": "20.0.0-beta.4",
-    "@nx/nx-linux-x64-musl": "20.0.0-beta.4",
-    "@nx/nx-win32-x64-msvc": "20.0.0-beta.4",
-    "@nx/nx-linux-arm64-gnu": "20.0.0-beta.4",
-    "@nx/nx-linux-arm64-musl": "20.0.0-beta.4",
-    "@nx/nx-linux-arm-gnueabihf": "20.0.0-beta.4",
-    "@nx/nx-win32-arm64-msvc": "20.0.0-beta.4",
-    "@nx/nx-freebsd-x64": "20.0.0-beta.4"
+    "@nx/nx-darwin-x64": "20.0.0-beta.5",
+    "@nx/nx-darwin-arm64": "20.0.0-beta.5",
+    "@nx/nx-linux-x64-gnu": "20.0.0-beta.5",
+    "@nx/nx-linux-x64-musl": "20.0.0-beta.5",
+    "@nx/nx-win32-x64-msvc": "20.0.0-beta.5",
+    "@nx/nx-linux-arm64-gnu": "20.0.0-beta.5",
+    "@nx/nx-linux-arm64-musl": "20.0.0-beta.5",
+    "@nx/nx-linux-arm-gnueabihf": "20.0.0-beta.5",
+    "@nx/nx-win32-arm64-msvc": "20.0.0-beta.5",
+    "@nx/nx-freebsd-x64": "20.0.0-beta.5"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/daemon/server/handle-hash-tasks.js

@@ -25,7 +25,7 @@ async function handleHashTasks(payload) {
     const nxJson = (0, configuration_1.readNxJson)();
     if (projectGraph !== storedProjectGraph) {
         storedProjectGraph = projectGraph;
-        storedHasher = new task_hasher_1.InProcessTaskHasher(fileMap?.projectFileMap, allWorkspaceFiles, projectGraph, nxJson, rustReferences, payload.runnerOptions);
+        storedHasher = new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, payload.runnerOptions);
     }
     const response = JSON.stringify(await storedHasher.hashTasks(payload.tasks, payload.taskGraph, payload.env));
     return {

package/src/executors/run-commands/run-commands.impl.js

@@ -16,22 +16,11 @@ let pseudoTerminal;
 const childProcesses = new Set();
 function loadEnvVarsFile(path, env = {}) {
     (0, task_env_1.unloadDotEnvFile)(path, env);
-    const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env, true);
+    const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env);
     if (result.error) {
         throw result.error;
     }
 }
-function loadEnvVars(path, env = {}) {
-    if (path) {
-        loadEnvVarsFile(path, env);
-    }
-    else {
-        try {
-            loadEnvVarsFile('.env', env);
-        }
-        catch { }
-    }
-}
 const propKeys = [
     'command',
     'commands',
@@ -292,20 +281,24 @@ function calculateCwd(cwd, context) {
         return cwd;
     return path.join(context.root, cwd);
 }
-function processEnv(color, cwd, env, envFile) {
-    const localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
-    let res = {
+/**
+ * Env variables are processed in the following order:
+ * - env option from executor options
+ * - env file from envFile option if provided
+ * - local env variables
+ */
+function processEnv(color, cwd, envOptionFromExecutor, envFile) {
+    let localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
+    localEnv = {
         ...process.env,
         ...localEnv,
     };
-    // env file from envFile option takes priority over process env
-    if (process.env.NX_LOAD_DOT_ENV_FILES !== 'false') {
-        loadEnvVars(envFile, res);
+    if (process.env.NX_LOAD_DOT_ENV_FILES !== 'false' && envFile) {
+        loadEnvVarsFile(envFile, localEnv);
     }
-    // env variables from env option takes priority over everything else
-    res = {
-        ...res,
-        ...env,
+    let res = {
+        ...localEnv,
+        ...envOptionFromExecutor,
     };
     // need to override PATH to make sure we are using the local node_modules
     if (localEnv.PATH)

package/src/hasher/create-task-hasher.js

@@ -10,6 +10,6 @@ function createTaskHasher(projectGraph, nxJson, runnerOptions) {
     }
     else {
         const { fileMap, allWorkspaceFiles, rustReferences } = (0, build_project_graph_1.getFileMap)();
-        return new task_hasher_1.InProcessTaskHasher(fileMap?.projectFileMap, allWorkspaceFiles, projectGraph, nxJson, rustReferences, runnerOptions);
+        return new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, runnerOptions);
     }
 }

package/src/hasher/task-hasher.d.ts

@@ -1,4 +1,4 @@
-import { FileData, ProjectFileMap, ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { FileData, ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
 import { NxJsonConfiguration } from '../config/nx-json';
 import { Task, TaskGraph } from '../config/task-graph';
 import { DaemonClient } from '../daemon/client/client';
@@ -66,16 +66,12 @@ export declare class DaemonBasedTaskHasher implements TaskHasher {
     hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv): Promise<Hash>;
 }
 export declare class InProcessTaskHasher implements TaskHasher {
-    private readonly projectFileMap;
-    private readonly allWorkspaceFiles;
     private readonly projectGraph;
     private readonly nxJson;
     private readonly externalRustReferences;
     private readonly options;
-    static version: string;
     private taskHasher;
-    private useNativeTaskHasher;
-    constructor(projectFileMap: ProjectFileMap, allWorkspaceFiles: FileData[], projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, externalRustReferences: NxWorkspaceFilesExternals | null, options: any);
+    constructor(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, externalRustReferences: NxWorkspaceFilesExternals | null, options: any);
     hashTasks(tasks: Task[], taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv): Promise<Hash[]>;
     hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv): Promise<Hash>;
     private createHashDetails;

package/src/hasher/task-hasher.js

@@ -11,7 +11,6 @@ exports.expandSingleProjectInputs = expandSingleProjectInputs;
 exports.expandNamedInput = expandNamedInput;
 exports.filterUsingGlobPatterns = filterUsingGlobPatterns;
 const file_hasher_1 = require("./file-hasher");
-const node_task_hasher_impl_1 = require("./node-task-hasher-impl");
 const minimatch_1 = require("minimatch");
 const native_task_hasher_impl_1 = require("./native-task-hasher-impl");
 const workspace_root_1 = require("../utils/workspace-root");
@@ -29,42 +28,18 @@ class DaemonBasedTaskHasher {
 }
 exports.DaemonBasedTaskHasher = DaemonBasedTaskHasher;
 class InProcessTaskHasher {
-    constructor(projectFileMap, allWorkspaceFiles, projectGraph, nxJson, externalRustReferences, options) {
-        this.projectFileMap = projectFileMap;
-        this.allWorkspaceFiles = allWorkspaceFiles;
+    constructor(projectGraph, nxJson, externalRustReferences, options) {
         this.projectGraph = projectGraph;
         this.nxJson = nxJson;
         this.externalRustReferences = externalRustReferences;
         this.options = options;
-        this.useNativeTaskHasher = process.env.NX_NATIVE_TASK_HASHER !== 'false';
-        const legacyRuntimeInputs = (this.options && this.options.runtimeCacheInputs
-            ? this.options.runtimeCacheInputs
-            : []).map((r) => ({ runtime: r }));
-        if (process.env.NX_CLOUD_ENCRYPTION_KEY) {
-            legacyRuntimeInputs.push({ env: 'NX_CLOUD_ENCRYPTION_KEY' });
-        }
-        const legacyFilesetInputs = [
-            'nx.json',
-            // ignore files will change the set of inputs to the hasher
-            '.gitignore',
-            '.nxignore',
-        ].map((d) => ({ fileset: `{workspaceRoot}/${d}` }));
-        this.taskHasher = !this.useNativeTaskHasher
-            ? new node_task_hasher_impl_1.NodeTaskHasherImpl(nxJson, legacyRuntimeInputs, legacyFilesetInputs, this.projectFileMap, this.allWorkspaceFiles, this.projectGraph, {
-                selectivelyHashTsConfig: this.options?.selectivelyHashTsConfig ?? false,
-            })
-            : new native_task_hasher_impl_1.NativeTaskHasherImpl(workspace_root_1.workspaceRoot, nxJson, this.projectGraph, this.externalRustReferences, {
-                selectivelyHashTsConfig: this.options?.selectivelyHashTsConfig ?? false,
-            });
+        this.taskHasher = new native_task_hasher_impl_1.NativeTaskHasherImpl(workspace_root_1.workspaceRoot, this.nxJson, this.projectGraph, this.externalRustReferences, {
+            selectivelyHashTsConfig: this.options?.selectivelyHashTsConfig ?? false,
+        });
     }
     async hashTasks(tasks, taskGraph, env) {
-        if (this.useNativeTaskHasher) {
-            const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, env ?? process.env);
-            return tasks.map((task, index) => this.createHashDetails(task, hashes[index]));
-        }
-        else {
-            return await Promise.all(tasks.map((t) => this.hashTask(t, taskGraph, env)));
-        }
+        const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, env ?? process.env);
+        return tasks.map((task, index) => this.createHashDetails(task, hashes[index]));
     }
     async hashTask(task, taskGraph, env) {
         const res = await this.taskHasher.hashTask(task, taskGraph, env ?? process.env);
@@ -98,7 +73,6 @@ class InProcessTaskHasher {
     }
 }
 exports.InProcessTaskHasher = InProcessTaskHasher;
-InProcessTaskHasher.version = '3.0';
 const DEFAULT_INPUTS = [
     {
         fileset: '{projectRoot}/**/*',

package/src/utils/plugins/output.js

@@ -47,7 +47,7 @@ function listAlsoAvailableCorePlugins(installedPlugins) {
     }
 }
 function listPowerpackPlugins() {
-    const powerpackLink = 'https://nx.dev/plugin-registry';
+    const powerpackLink = 'https://nx.dev/plugin-registry#powerpack';
     output_1.output.log({
         title: `Available Powerpack Plugins: ${powerpackLink}`,
     });

package/src/hasher/node-task-hasher-impl.d.ts

@@ -1,48 +0,0 @@
-import { NxJsonConfiguration } from '../config/nx-json';
-import { FileData, ProjectFileMap, ProjectGraph } from '../config/project-graph';
-import { Task, TaskGraph } from '../config/task-graph';
-import { PartialHash, TaskHasherImpl } from './task-hasher';
-export declare class NodeTaskHasherImpl implements TaskHasherImpl {
-    private readonly nxJson;
-    private readonly legacyRuntimeInputs;
-    private readonly legacyFilesetInputs;
-    private readonly projectFileMap;
-    private readonly allWorkspaceFiles;
-    private readonly projectGraph;
-    private readonly options;
-    private filesetHashes;
-    private runtimeHashes;
-    private externalDependencyHashes;
-    private allExternalDependenciesHash;
-    private projectRootMappings;
-    constructor(nxJson: NxJsonConfiguration, legacyRuntimeInputs: {
-        runtime: string;
-    }[], legacyFilesetInputs: {
-        fileset: string;
-    }[], projectFileMap: ProjectFileMap, allWorkspaceFiles: FileData[], projectGraph: ProjectGraph, options: {
-        selectivelyHashTsConfig: boolean;
-    });
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<PartialHash[]>;
-    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, visited?: string[]): Promise<PartialHash>;
-    private hashNamedInputForDependencies;
-    private hashSelfAndDepsInputs;
-    private combinePartialHashes;
-    private hashDepsInputs;
-    private hashDepsOutputs;
-    private hashDepOuputs;
-    private hashFiles;
-    private getExternalDependencyHash;
-    private hashSingleExternalDependency;
-    private hashExternalDependency;
-    private hashTarget;
-    private findExternalDependencyNodeName;
-    private hashSingleProjectInputs;
-    private hashProjectInputs;
-    private hashRootFilesets;
-    private hashProjectConfig;
-    private hashTsConfig;
-    private hashProjectFileset;
-    private hashRuntime;
-    private hashEnv;
-    private calculateExternalDependencyHashes;
-}

package/src/hasher/node-task-hasher-impl.js

@@ -1,449 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeTaskHasherImpl = void 0;
-const find_project_for_path_1 = require("../project-graph/utils/find-project-for-path");
-const file_hasher_1 = require("./file-hasher");
-const utils_1 = require("../tasks-runner/utils");
-const workspace_root_1 = require("../utils/workspace-root");
-const minimatch_1 = require("minimatch");
-const path_1 = require("path");
-const native_1 = require("../native");
-const project_graph_utils_1 = require("../utils/project-graph-utils");
-const find_matching_projects_1 = require("../utils/find-matching-projects");
-const child_process_1 = require("child_process");
-const task_hasher_1 = require("./task-hasher");
-const hasher_1 = require("../plugins/js/hasher/hasher");
-class NodeTaskHasherImpl {
-    constructor(nxJson, legacyRuntimeInputs, legacyFilesetInputs, projectFileMap, allWorkspaceFiles, projectGraph, options) {
-        this.nxJson = nxJson;
-        this.legacyRuntimeInputs = legacyRuntimeInputs;
-        this.legacyFilesetInputs = legacyFilesetInputs;
-        this.projectFileMap = projectFileMap;
-        this.allWorkspaceFiles = allWorkspaceFiles;
-        this.projectGraph = projectGraph;
-        this.options = options;
-        this.filesetHashes = {};
-        this.runtimeHashes = {};
-        this.externalDependencyHashes = new Map();
-        this.projectRootMappings = (0, find_project_for_path_1.createProjectRootMappings)(this.projectGraph.nodes);
-        // External Dependencies are all calculated up front in a deterministic order
-        this.calculateExternalDependencyHashes();
-    }
-    hashTasks(tasks, taskGraph, env) {
-        return Promise.all(tasks.map((t) => this.hashTask(t, taskGraph, env, [])));
-    }
-    async hashTask(task, taskGraph, env, visited = []) {
-        return Promise.resolve().then(async () => {
-            const { selfInputs, depsInputs, depsOutputs, projectInputs } = (0, task_hasher_1.getInputs)(task, this.projectGraph, this.nxJson);
-            const selfAndInputs = await this.hashSelfAndDepsInputs(task.target.project, task, selfInputs, depsInputs, depsOutputs, projectInputs, taskGraph, env, visited);
-            const target = this.hashTarget(task.target.project, task.target.target, selfInputs);
-            if (target) {
-                return this.combinePartialHashes([selfAndInputs, target]);
-            }
-            return selfAndInputs;
-        });
-    }
-    async hashNamedInputForDependencies(projectName, task, namedInput, taskGraph, env, visited) {
-        const projectNode = this.projectGraph.nodes[projectName];
-        const namedInputs = {
-            default: [{ fileset: '{projectRoot}/**/*' }],
-            ...this.nxJson.namedInputs,
-            ...projectNode.data.namedInputs,
-        };
-        const expandedInputs = (0, task_hasher_1.expandNamedInput)(namedInput, namedInputs);
-        const selfInputs = expandedInputs.filter(task_hasher_1.isSelfInput);
-        const depsOutputs = expandedInputs.filter(task_hasher_1.isDepsOutput);
-        const depsInputs = [{ input: namedInput, dependencies: true }]; // true is boolean by default
-        return this.hashSelfAndDepsInputs(projectName, task, selfInputs, depsInputs, depsOutputs, [], taskGraph, env, visited);
-    }
-    async hashSelfAndDepsInputs(projectName, task, selfInputs, depsInputs, depsOutputs, projectInputs, taskGraph, env, visited) {
-        const projectGraphDeps = this.projectGraph.dependencies[projectName] ?? [];
-        // we don't want random order of dependencies to change the hash
-        projectGraphDeps.sort((a, b) => a.target.localeCompare(b.target));
-        const self = await this.hashSingleProjectInputs(projectName, selfInputs, env);
-        const deps = await this.hashDepsInputs(task, depsInputs, projectGraphDeps, taskGraph, env, visited);
-        const depsOut = await this.hashDepsOutputs(task, depsOutputs, taskGraph);
-        const projects = await this.hashProjectInputs(projectInputs, env);
-        return this.combinePartialHashes([
-            ...self,
-            ...deps,
-            ...projects,
-            ...depsOut,
-        ]);
-    }
-    combinePartialHashes(partialHashes) {
-        if (partialHashes.length === 1) {
-            return partialHashes[0];
-        }
-        const details = {};
-        const hashValues = [];
-        for (const partial of partialHashes) {
-            hashValues.push(partial.value);
-            Object.assign(details, partial.details);
-        }
-        const value = (0, file_hasher_1.hashArray)(hashValues);
-        return { value, details };
-    }
-    async hashDepsInputs(task, inputs, projectGraphDeps, taskGraph, env, visited) {
-        return (await Promise.all(inputs.map(async (input) => {
-            return await Promise.all(projectGraphDeps.map(async (d) => {
-                if (visited.indexOf(d.target) > -1) {
-                    return null;
-                }
-                else {
-                    visited.push(d.target);
-                    if (this.projectGraph.nodes[d.target]) {
-                        return await this.hashNamedInputForDependencies(d.target, task, input.input || 'default', taskGraph, env, visited);
-                    }
-                    else {
-                        return this.getExternalDependencyHash(d.target);
-                    }
-                }
-            }));
-        })))
-            .flat()
-            .filter((r) => !!r);
-    }
-    async hashDepsOutputs(task, depsOutputs, taskGraph) {
-        if (depsOutputs.length === 0) {
-            return [];
-        }
-        const result = [];
-        for (const { dependentTasksOutputFiles, transitive } of depsOutputs) {
-            result.push(...(await this.hashDepOuputs(task, dependentTasksOutputFiles, taskGraph, transitive)));
-        }
-        return result;
-    }
-    async hashDepOuputs(task, dependentTasksOutputFiles, taskGraph, transitive) {
-        // task has no dependencies
-        if (!taskGraph.dependencies[task.id]) {
-            return [];
-        }
-        const partialHashes = [];
-        for (const d of taskGraph.dependencies[task.id]) {
-            const childTask = taskGraph.tasks[d];
-            const outputs = (0, utils_1.getOutputsForTargetAndConfiguration)(childTask.target, childTask.overrides, this.projectGraph.nodes[childTask.target.project]);
-            const { getFilesForOutputs } = require('../native');
-            const outputFiles = getFilesForOutputs(workspace_root_1.workspaceRoot, outputs);
-            const filteredFiles = outputFiles.filter((p) => p === dependentTasksOutputFiles ||
-                (0, minimatch_1.minimatch)(p, dependentTasksOutputFiles, { dot: true }));
-            const hashDetails = {};
-            const hashes = [];
-            for (const [file, hash] of this.hashFiles(filteredFiles.map((p) => (0, path_1.join)(workspace_root_1.workspaceRoot, p)))) {
-                hashes.push(hash);
-            }
-            let hash = (0, file_hasher_1.hashArray)(hashes);
-            partialHashes.push({
-                value: hash,
-                details: {
-                    [`${dependentTasksOutputFiles}:${outputs.join(',')}`]: hash,
-                },
-            });
-            if (transitive) {
-                partialHashes.push(...(await this.hashDepOuputs(childTask, dependentTasksOutputFiles, taskGraph, transitive)));
-            }
-        }
-        return partialHashes;
-    }
-    hashFiles(files) {
-        const r = new Map();
-        for (let f of files) {
-            r.set(f, (0, native_1.hashFile)(f));
-        }
-        return r;
-    }
-    getExternalDependencyHash(externalNodeName) {
-        const combinedHash = this.combinePartialHashes(this.externalDependencyHashes.get(externalNodeName));
-        // Set the combined hash into the hashes so it's not recalculated next time
-        this.externalDependencyHashes.set(externalNodeName, [combinedHash]);
-        return combinedHash;
-    }
-    hashSingleExternalDependency(externalNodeName) {
-        const node = this.projectGraph.externalNodes[externalNodeName];
-        if (node.data.hash) {
-            // we already know the hash of this dependency
-            return {
-                value: node.data.hash,
-                details: {
-                    [externalNodeName]: node.data.hash,
-                },
-            };
-        }
-        else {
-            // we take version as a hash
-            return {
-                value: node.data.version,
-                details: {
-                    [externalNodeName]: node.data.version,
-                },
-            };
-        }
-    }
-    hashExternalDependency(externalNodeName) {
-        const partialHashes = new Set();
-        partialHashes.add(this.hashSingleExternalDependency(externalNodeName));
-        const deps = (0, project_graph_utils_1.findAllProjectNodeDependencies)(externalNodeName, this.projectGraph, true);
-        for (const dep of deps) {
-            partialHashes.add(this.hashSingleExternalDependency(dep));
-        }
-        return Array.from(partialHashes);
-    }
-    hashTarget(projectName, targetName, selfInputs) {
-        const projectNode = this.projectGraph.nodes[projectName];
-        const target = projectNode.data.targets[targetName];
-        if (!target) {
-            return;
-        }
-        let hash;
-        // we can only vouch for @nx packages's executor dependencies
-        // if it's "run commands" or third-party we skip traversing since we have no info what this command depends on
-        if (target.executor.startsWith(`@nrwl/`) ||
-            target.executor.startsWith(`@nx/`)) {
-            const executorPackage = target.executor.split(':')[0];
-            const executorNodeName = this.findExternalDependencyNodeName(executorPackage);
-            // This is either a local plugin or a non-existent executor
-            if (!executorNodeName) {
-                // TODO: This should not return null if it is a local plugin's executor
-                return null;
-            }
-            return this.getExternalDependencyHash(executorNodeName);
-        }
-        else {
-            // use command external dependencies if available to construct the hash
-            const partialHashes = [];
-            let hasCommandExternalDependencies = false;
-            for (const input of selfInputs) {
-                if (input['externalDependencies']) {
-                    // if we have externalDependencies with empty array we still want to override the default hash
-                    hasCommandExternalDependencies = true;
-                    const externalDependencies = input['externalDependencies'];
-                    for (let dep of externalDependencies) {
-                        dep = this.findExternalDependencyNodeName(dep);
-                        if (!dep) {
-                            throw new Error(`The externalDependency "${dep}" for "${projectName}:${targetName}" could not be found`);
-                        }
-                        partialHashes.push(this.getExternalDependencyHash(dep));
-                    }
-                }
-            }
-            if (hasCommandExternalDependencies) {
-                return this.combinePartialHashes(partialHashes);
-            }
-            else {
-                // cache the hash of the entire external dependencies tree
-                if (this.allExternalDependenciesHash) {
-                    return this.allExternalDependenciesHash;
-                }
-                else {
-                    hash = (0, file_hasher_1.hashObject)(this.projectGraph.externalNodes);
-                    this.allExternalDependenciesHash = {
-                        value: hash,
-                        details: {
-                            AllExternalDependencies: hash,
-                        },
-                    };
-                    return this.allExternalDependenciesHash;
-                }
-            }
-        }
-    }
-    findExternalDependencyNodeName(packageName) {
-        if (this.projectGraph.externalNodes[packageName]) {
-            return packageName;
-        }
-        if (this.projectGraph.externalNodes[`npm:${packageName}`]) {
-            return `npm:${packageName}`;
-        }
-        for (const node of Object.values(this.projectGraph.externalNodes)) {
-            if (node.data.packageName === packageName) {
-                return node.name;
-            }
-        }
-        // not found
-        return null;
-    }
-    async hashSingleProjectInputs(projectName, inputs, env) {
-        const filesets = (0, task_hasher_1.extractPatternsFromFileSets)(inputs);
-        const projectFilesets = [];
-        const workspaceFilesets = [];
-        let invalidFilesetNoPrefix = null;
-        let invalidFilesetWorkspaceRootNegative = null;
-        for (let f of filesets) {
-            if (f.startsWith('{projectRoot}/') || f.startsWith('!{projectRoot}/')) {
-                projectFilesets.push(f);
-            }
-            else if (f.startsWith('{workspaceRoot}/') ||
-                f.startsWith('!{workspaceRoot}/')) {
-                workspaceFilesets.push(f);
-            }
-            else {
-                invalidFilesetNoPrefix = f;
-            }
-        }
-        if (invalidFilesetNoPrefix) {
-            throw new Error([
-                `"${invalidFilesetNoPrefix}" is an invalid fileset.`,
-                'All filesets have to start with either {workspaceRoot} or {projectRoot}.',
-                'For instance: "!{projectRoot}/**/*.spec.ts" or "{workspaceRoot}/package.json".',
-                `If "${invalidFilesetNoPrefix}" is a named input, make sure it is defined in, for instance, nx.json.`,
-            ].join('\n'));
-        }
-        if (invalidFilesetWorkspaceRootNegative) {
-            throw new Error([
-                `"${invalidFilesetWorkspaceRootNegative}" is an invalid fileset.`,
-                'It is not possible to negative filesets starting with {workspaceRoot}.',
-            ].join('\n'));
-        }
-        const notFilesets = inputs.filter((r) => !r['fileset']);
-        return Promise.all([
-            this.hashProjectFileset(projectName, projectFilesets),
-            this.hashProjectConfig(projectName),
-            this.hashTsConfig(projectName),
-            ...(workspaceFilesets.length
-                ? [this.hashRootFilesets(workspaceFilesets)]
-                : []),
-            this.hashRootFilesets(this.legacyFilesetInputs.map((r) => r.fileset)),
-            ...[...notFilesets, ...this.legacyRuntimeInputs].map((r) => r['runtime']
-                ? this.hashRuntime(env, r['runtime'])
-                : this.hashEnv(env, r['env'])),
-        ]);
-    }
-    async hashProjectInputs(projectInputs, env) {
-        const partialHashes = [];
-        for (const input of projectInputs) {
-            const projects = (0, find_matching_projects_1.findMatchingProjects)(input.projects, this.projectGraph.nodes);
-            for (const project of projects) {
-                const namedInputs = (0, task_hasher_1.getNamedInputs)(this.nxJson, this.projectGraph.nodes[project]);
-                const expandedInput = (0, task_hasher_1.expandSingleProjectInputs)([{ input: input.input }], namedInputs);
-                partialHashes.push(this.hashSingleProjectInputs(project, expandedInput, env));
-            }
-        }
-        return Promise.all(partialHashes).then((hashes) => hashes.flat());
-    }
-    async hashRootFilesets(filesets) {
-        const mapKey = `workspace:[${filesets.join(',')}]`;
-        if (!this.filesetHashes[mapKey]) {
-            this.filesetHashes[mapKey] = new Promise(async (res) => {
-                const parts = [];
-                const negativePatterns = [];
-                const positivePatterns = [];
-                for (const fileset of filesets) {
-                    if (fileset.startsWith('!')) {
-                        negativePatterns.push(fileset.substring(17));
-                    }
-                    else {
-                        positivePatterns.push(fileset.substring(16));
-                    }
-                }
-                for (const fileset of positivePatterns) {
-                    const withoutWorkspaceRoot = fileset;
-                    // Used to shortcut minimatch if not necessary
-                    const matchingFile = this.allWorkspaceFiles.find((t) => t.file === withoutWorkspaceRoot);
-                    // shortcut because there is a direct match
-                    if (matchingFile) {
-                        if (!negativePatterns.some((p) => (0, minimatch_1.minimatch)(matchingFile.file, p))) {
-                            parts.push(matchingFile.hash);
-                        }
-                        // No direct match, check if pattern matched
-                    }
-                    else {
-                        this.allWorkspaceFiles
-                            .filter((f) => (0, minimatch_1.minimatch)(f.file, withoutWorkspaceRoot) &&
-                            !negativePatterns.some((p) => (0, minimatch_1.minimatch)(f.file, p)))
-                            .forEach((f) => {
-                            parts.push(f.hash);
-                        });
-                    }
-                }
-                const value = (0, file_hasher_1.hashArray)(parts);
-                res({
-                    value,
-                    details: { [mapKey]: value },
-                });
-            });
-        }
-        return this.filesetHashes[mapKey];
-    }
-    hashProjectConfig(projectName) {
-        const p = this.projectGraph.nodes[projectName];
-        const projectConfig = (0, file_hasher_1.hashArray)([
-            JSON.stringify({ ...p.data, files: undefined }),
-        ]);
-        return {
-            value: projectConfig,
-            details: {
-                [`${projectName}:ProjectConfiguration`]: projectConfig,
-            },
-        };
-    }
-    hashTsConfig(projectName) {
-        const p = this.projectGraph.nodes[projectName];
-        const tsConfig = (0, file_hasher_1.hashArray)([
-            (0, hasher_1.hashTsConfig)(p, this.projectRootMappings, this.options),
-        ]);
-        return {
-            value: tsConfig,
-            details: {
-                [`${projectName}:TsConfig`]: tsConfig,
-            },
-        };
-    }
-    async hashProjectFileset(projectName, filesetPatterns) {
-        const mapKey = `${projectName}:${filesetPatterns.join(',')}`;
-        if (!this.filesetHashes[mapKey]) {
-            this.filesetHashes[mapKey] = new Promise(async (res) => {
-                const p = this.projectGraph.nodes[projectName];
-                const filteredFiles = (0, task_hasher_1.filterUsingGlobPatterns)(p.data.root, this.projectFileMap[projectName] || [], filesetPatterns);
-                const files = [];
-                for (const { file, hash } of filteredFiles) {
-                    files.push(file, hash);
-                }
-                const value = (0, file_hasher_1.hashArray)(files);
-                res({
-                    value,
-                    details: { [mapKey]: value },
-                });
-            });
-        }
-        return this.filesetHashes[mapKey];
-    }
-    async hashRuntime(env, runtime) {
-        const env_key = JSON.stringify(env);
-        const mapKey = `runtime:${runtime}-${env_key}`;
-        if (!this.runtimeHashes[mapKey]) {
-            this.runtimeHashes[mapKey] = new Promise((res, rej) => {
-                (0, child_process_1.exec)(runtime, {
-                    windowsHide: true,
-                    cwd: workspace_root_1.workspaceRoot,
-                    env,
-                }, (err, stdout, stderr) => {
-                    if (err) {
-                        rej(new Error(`Nx failed to execute {runtime: '${runtime}'}. ${err}.`));
-                    }
-                    else {
-                        const value = (0, file_hasher_1.hashArray)([`${stdout}${stderr}`.trim()]);
-                        res({
-                            details: { [`runtime:${runtime}`]: value },
-                            value,
-                        });
-                    }
-                });
-            });
-        }
-        return this.runtimeHashes[mapKey];
-    }
-    async hashEnv(env, envVarName) {
-        const value = (0, file_hasher_1.hashArray)([env[envVarName] ?? '']);
-        return {
-            details: { [`env:${envVarName}`]: value },
-            value,
-        };
-    }
-    calculateExternalDependencyHashes() {
-        const keys = Object.keys(this.projectGraph.externalNodes);
-        for (const externalNodeName of keys) {
-            this.externalDependencyHashes.set(externalNodeName, this.hashExternalDependency(externalNodeName));
-        }
-    }
-}
-exports.NodeTaskHasherImpl = NodeTaskHasherImpl;