nx 20.0.0-canary.20240926-529ab94 → 20.0.0-canary.20241001-8fa7065

package/src/core/graph/styles.js

@@ -1 +1 @@
-"use strict";(self.webpackChunk=self.webpackChunk||[]).push([[532],{50921:()=>{}},s=>{var e;e=50921,s(s.s=e)}]);
+"use strict";(self.webpackChunk=self.webpackChunk||[]).push([[532],{71970:()=>{}},s=>{var e;e=71970,s(s.s=e)}]);

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/generators/utils/project-configuration.js

@@ -69,7 +69,8 @@ function updateProjectConfiguration(tree, projectName, projectConfiguration) {
 function updateProjectConfigurationInPackageJson(tree, projectName, projectConfiguration) {
     const packageJsonFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'package.json');
     const packageJson = (0, json_1.readJson)(tree, packageJsonFile);
-    if (packageJson.name === projectConfiguration.name ?? projectName) {
+    projectConfiguration.name = projectName;
+    if (packageJson.name === projectConfiguration.name) {
         delete projectConfiguration.name;
     }
     if (projectConfiguration.targets &&

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/hash-task.d.ts

@@ -2,5 +2,7 @@ import { Task, TaskGraph } from '../config/task-graph';
 import { TaskHasher } from './task-hasher';
 import { ProjectGraph } from '../config/project-graph';
 import { NxJsonConfiguration } from '../config/nx-json';
-export declare function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration): Promise<void>;
-export declare function hashTask(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, task: Task, env: NodeJS.ProcessEnv): Promise<void>;
+import { TaskDetails } from '../native';
+export declare function getTaskDetails(): TaskDetails | null;
+export declare function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, tasksDetails: TaskDetails | null): Promise<void>;
+export declare function hashTask(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, task: Task, env: NodeJS.ProcessEnv, taskDetails: TaskDetails | null): Promise<void>;

package/src/hasher/hash-task.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTaskDetails = getTaskDetails;
 exports.hashTasksThatDoNotDependOnOutputsOfOtherTasks = hashTasksThatDoNotDependOnOutputsOfOtherTasks;
 exports.hashTask = hashTask;
 const utils_1 = require("../tasks-runner/utils");
@@ -19,9 +20,8 @@ function getTaskDetails() {
     }
     return taskDetails;
 }
-async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson) {
+async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson, tasksDetails) {
     performance.mark('hashMultipleTasks:start');
-    const taskDetails = getTaskDetails();
     const tasks = Object.values(taskGraph.tasks);
     const tasksWithHashers = await Promise.all(tasks.map(async (task) => {
         const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
@@ -42,9 +42,8 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
         tasksToHash[i].hash = hashes[i].value;
         tasksToHash[i].hashDetails = hashes[i].details;
     }
-    // TODO: Remove if when sqlite is always on
-    if (taskDetails) {
-        taskDetails.recordTaskDetails(tasksToHash.map((task) => ({
+    if (tasksDetails?.recordTaskDetails) {
+        tasksDetails.recordTaskDetails(tasksToHash.map((task) => ({
             hash: task.hash,
             project: task.target.project,
             target: task.target.target,
@@ -54,9 +53,8 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
     performance.mark('hashMultipleTasks:end');
     performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');
 }
-async function hashTask(hasher, projectGraph, taskGraph, task, env) {
+async function hashTask(hasher, projectGraph, taskGraph, task, env, taskDetails) {
     performance.mark('hashSingleTask:start');
-    const taskDetails = getTaskDetails();
     const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
     const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
     const { value, details } = await (customHasher
@@ -72,8 +70,7 @@ async function hashTask(hasher, projectGraph, taskGraph, task, env) {
         : hasher.hashTask(task, taskGraph, env));
     task.hash = value;
     task.hashDetails = details;
-    // TODO: Remove if when wasm supports sqlite
-    if (taskDetails) {
+    if (taskDetails?.recordTaskDetails) {
         taskDetails.recordTaskDetails([
             {
                 hash: task.hash,

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/tasks-runner/forked-process-task-runner.js

@@ -4,7 +4,6 @@ exports.ForkedProcessTaskRunner = void 0;
 const fs_1 = require("fs");
 const child_process_1 = require("child_process");
 const chalk = require("chalk");
-const logTransformer = require("strong-log-transformer");
 const output_1 = require("../utils/output");
 const utils_1 = require("./utils");
 const path_1 = require("path");
@@ -208,16 +207,16 @@ class ForkedProcessTaskRunner {
                         const prefixText = `${task.target.project}:`;
                         p.stdout
                             .pipe(logClearLineToPrefixTransformer(color.bold(prefixText) + ' '))
-                            .pipe(logTransformer({ tag: color.bold(prefixText) }))
+                            .pipe(addPrefixTransformer(color.bold(prefixText)))
                             .pipe(process.stdout);
                         p.stderr
                             .pipe(logClearLineToPrefixTransformer(color(prefixText) + ' '))
-                            .pipe(logTransformer({ tag: color(prefixText) }))
+                            .pipe(addPrefixTransformer(color(prefixText)))
                             .pipe(process.stderr);
                     }
                     else {
-                        p.stdout.pipe(logTransformer()).pipe(process.stdout);
-                        p.stderr.pipe(logTransformer()).pipe(process.stderr);
+                        p.stdout.pipe(addPrefixTransformer()).pipe(process.stdout);
+                        p.stderr.pipe(addPrefixTransformer()).pipe(process.stderr);
                     }
                 }
                 let outWithErr = [];
@@ -403,3 +402,15 @@ function logClearLineToPrefixTransformer(prefix) {
         },
     });
 }
+function addPrefixTransformer(prefix) {
+    const newLineSeparator = process.platform.startsWith('win') ? '\r\n' : '\n';
+    return new stream_1.Transform({
+        transform(chunk, _encoding, callback) {
+            const list = chunk.toString().split(/\r\n|[\n\v\f\r\x85\u2028\u2029]/g);
+            list
+                .filter(Boolean)
+                .forEach((m) => this.push(prefix ? prefix + ' ' + m + newLineSeparator : m + newLineSeparator));
+            callback();
+        },
+    });
+}

package/src/tasks-runner/life-cycles/dynamic-run-many-terminal-output-life-cycle.js

@@ -224,6 +224,11 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
         clearRenderInterval();
         const timeTakenText = (0, pretty_time_1.prettyTime)(process.hrtime(start));
         moveCursorToStartOfPinnedFooter();
+        if (totalTasks === 0) {
+            renderPinnedFooter([output_1.output.applyNxPrefix('gray', 'No tasks were run')]);
+            resolveRenderIsDonePromise();
+            return;
+        }
         if (totalSuccessfulTasks === totalTasks) {
             const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
             const taskOverridesRows = [];

package/src/tasks-runner/life-cycles/static-run-many-terminal-output-life-cycle.js

@@ -23,6 +23,9 @@ class StaticRunManyTerminalOutputLifeCycle {
         this.allCompletedTasks = new Map();
     }
     startCommand() {
+        if (this.tasks.length === 0) {
+            return;
+        }
         if (this.projectNames.length <= 0) {
             output_1.output.logSingleLine(`No projects with ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} were run`);
             return;
@@ -45,6 +48,10 @@ class StaticRunManyTerminalOutputLifeCycle {
     }
     endCommand() {
         output_1.output.addNewline();
+        if (this.tasks.length === 0) {
+            output_1.output.logSingleLine(`No tasks were run`);
+            return;
+        }
         if (this.failedTasks.length === 0) {
             output_1.output.addVerticalSeparatorWithoutNewLines('green');
             const bodyLines = this.cachedTasks.length > 0

package/src/tasks-runner/run-command.js

@@ -363,12 +363,14 @@ function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
 }
 async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }) {
     setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles);
+    // this needs to be done before we start to run the tasks
+    const taskDetails = (0, hash_task_1.getTaskDetails)();
     const { tasksRunner, runnerOptions } = getRunner(nxArgs, nxJson);
     let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, runnerOptions);
     // this is used for two reasons: to fetch all remote cache hits AND
     // to submit everything that is known in advance to Nx Cloud to run in
     // a distributed fashion
-    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson);
+    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
     const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
         ...constructLifeCycles(lifeCycle),

package/src/tasks-runner/task-orchestrator.d.ts

@@ -15,6 +15,7 @@ export declare class TaskOrchestrator {
     private readonly bail;
     private readonly daemon;
     private readonly outputStyle;
+    private taskDetails;
     private cache;
     private forkedProcessTaskRunner;
     private tasksSchedule;

package/src/tasks-runner/task-orchestrator.js

@@ -27,6 +27,7 @@ class TaskOrchestrator {
         this.bail = bail;
         this.daemon = daemon;
         this.outputStyle = outputStyle;
+        this.taskDetails = (0, hash_task_1.getTaskDetails)();
         this.cache = (0, cache_1.getCache)(this.nxJson, this.options);
         this.forkedProcessTaskRunner = new forked_process_task_runner_1.ForkedProcessTaskRunner(this.options);
         this.tasksSchedule = new tasks_schedule_1.TasksSchedule(this.projectGraph, this.taskGraph, this.options);
@@ -93,7 +94,7 @@ class TaskOrchestrator {
         const task = this.taskGraph.tasks[taskId];
         const taskSpecificEnv = (0, task_env_1.getTaskSpecificEnv)(task);
         if (!task.hash) {
-            await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, taskSpecificEnv);
+            await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, taskSpecificEnv, this.taskDetails);
         }
         await this.options.lifeCycle.scheduleTask(task);
         return taskSpecificEnv;
@@ -101,7 +102,7 @@ class TaskOrchestrator {
     async processScheduledBatch(batch) {
         await Promise.all(Object.values(batch.taskGraph.tasks).map(async (task) => {
             if (!task.hash) {
-                await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, this.batchEnv);
+                await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, this.batchEnv, this.taskDetails);
             }
             await this.options.lifeCycle.scheduleTask(task);
         }));
@@ -321,6 +322,9 @@ class TaskOrchestrator {
             };
         }
         catch (e) {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.error(e);
+            }
             return {
                 code: 1,
             };

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

@@ -19,6 +19,7 @@ export declare class TasksSchedule {
     private completedTasks;
     private scheduleRequestsExecutionChain;
     private estimatedTaskTimings;
+    private projectDependencies;
     constructor(projectGraph: ProjectGraph, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions);
     init(): Promise<void>;
     scheduleNextTasks(): Promise<void>;

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

@@ -20,12 +20,16 @@ class TasksSchedule {
         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 =
@@ -90,8 +94,8 @@ class TasksSchedule {
             // 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 = (0, project_graph_utils_1.findAllProjectNodeDependencies)(project1, this.reverseProjectGraph).length;
-            const project2NodeDependencies = (0, project_graph_utils_1.findAllProjectNodeDependencies)(project2, this.reverseProjectGraph).length;
+            const project1NodeDependencies = this.projectDependencies[project1];
+            const project2NodeDependencies = this.projectDependencies[project2];
             const dependenciesDiff = project2NodeDependencies - project1NodeDependencies;
             if (dependenciesDiff !== 0) {
                 return dependenciesDiff;

package/src/utils/package-json.d.ts

@@ -52,6 +52,7 @@ export interface PackageJson {
         packages: string[];
     };
     publishConfig?: Record<string, string>;
+    files?: string[];
     nx?: NxProjectPackageJsonConfiguration;
     generators?: string;
     schematics?: string;

package/src/utils/plugins/core-plugins.js

@@ -82,6 +82,10 @@ exports.CORE_PLUGINS = [
         name: '@nx/rollup',
         capabilities: 'executors,generators',
     },
+    {
+        name: '@nx/rspack',
+        capabilities: 'executors,generators',
+    },
     {
         name: '@nx/storybook',
         capabilities: 'executors,generators',

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;
-}