@depup/nx 22.5.4-depup.0

package/src/generators/utils/nx-json.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNxJson = readNxJson;
+exports.updateNxJson = updateNxJson;
+const path_1 = require("path");
+const json_1 = require("./json");
+/**
+ * Reads nx.json
+ */
+function readNxJson(tree) {
+    if (!tree.exists('nx.json')) {
+        return null;
+    }
+    let nxJson = (0, json_1.readJson)(tree, 'nx.json');
+    if (nxJson.extends) {
+        nxJson = { ...readNxJsonExtends(tree, nxJson.extends), ...nxJson };
+    }
+    return nxJson;
+}
+/**
+ * Update nx.json
+ */
+function updateNxJson(tree, nxJson) {
+    if (tree.exists('nx.json')) {
+        (0, json_1.updateJson)(tree, 'nx.json', (json) => {
+            if (json.extends) {
+                const nxJsonExtends = readNxJsonExtends(tree, json.extends);
+                const changedPropsOfNxJson = {};
+                Object.keys(nxJson).forEach((prop) => {
+                    if (JSON.stringify(nxJson[prop], null, 2) !=
+                        JSON.stringify(nxJsonExtends[prop], null, 2)) {
+                        changedPropsOfNxJson[prop] = nxJson[prop];
+                    }
+                });
+                return changedPropsOfNxJson;
+            }
+            else {
+                return nxJson;
+            }
+        });
+    }
+}
+function readNxJsonExtends(tree, extendsPath) {
+    try {
+        return (0, json_1.readJson)(tree, (0, path_1.relative)(tree.root, require.resolve(extendsPath, {
+            paths: [tree.root],
+        })));
+    }
+    catch (e) {
+        throw new Error(`Unable to resolve nx.json extends. Error: ${e.message}`);
+    }
+}

package/src/generators/utils/project-configuration.d.ts

@@ -0,0 +1,43 @@
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import type { Tree } from '../tree';
+export { readNxJson, updateNxJson } from './nx-json';
+/**
+ * Adds project configuration to the Nx workspace.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ * @param projectConfiguration - project configuration
+ * @param standalone - whether the project is configured in workspace.json or not
+ */
+export declare function addProjectConfiguration(tree: Tree, projectName: string, projectConfiguration: ProjectConfiguration, standalone?: boolean): void;
+/**
+ * Updates the configuration of an existing project.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ * @param projectConfiguration - project configuration
+ */
+export declare function updateProjectConfiguration(tree: Tree, projectName: string, projectConfiguration: ProjectConfiguration): void;
+/**
+ * Removes the configuration of an existing project.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ */
+export declare function removeProjectConfiguration(tree: Tree, projectName: string): void;
+/**
+ * Reads a project configuration.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ * @throws If supplied projectName cannot be found
+ */
+export declare function readProjectConfiguration(tree: Tree, projectName: string): ProjectConfiguration;
+/**
+ * Get a map of all projects in a workspace.
+ *
+ * Use {@link readProjectConfiguration} if only one project is needed.
+ */
+export declare function getProjects(tree: Tree): Map<string, ProjectConfiguration>;
+export declare function getRelativeProjectJsonSchemaPath(tree: Tree, project: ProjectConfiguration): string;
+//# sourceMappingURL=project-configuration.d.ts.map

package/src/generators/utils/project-configuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-configuration.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/generators/utils/project-configuration.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,oBAAoB,EAErB,MAAM,0CAA0C,CAAC;AAYlD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAGpC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAErD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,EACnB,oBAAoB,EAAE,oBAAoB,EAC1C,UAAU,UAAO,GAChB,IAAI,CA6BN;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,EACnB,oBAAoB,EAAE,oBAAoB,GACzC,IAAI,CAsBN;AAgED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,GAClB,IAAI,CAYN;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,GAClB,oBAAoB,CAYtB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAYzE;AAED,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,oBAAoB,GAC5B,MAAM,CAOR"}

package/src/generators/utils/project-configuration.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateNxJson = exports.readNxJson = void 0;
+exports.addProjectConfiguration = addProjectConfiguration;
+exports.updateProjectConfiguration = updateProjectConfiguration;
+exports.removeProjectConfiguration = removeProjectConfiguration;
+exports.readProjectConfiguration = readProjectConfiguration;
+exports.getProjects = getProjects;
+exports.getRelativeProjectJsonSchemaPath = getRelativeProjectJsonSchemaPath;
+const minimatch_1 = require("minimatch");
+const path_1 = require("path");
+const package_json_1 = require("../../plugins/package-json");
+const project_json_1 = require("../../plugins/project-json/build-nodes/project-json");
+const angular_json_1 = require("../../adapter/angular-json");
+const project_configuration_utils_1 = require("../../project-graph/utils/project-configuration-utils");
+const workspace_context_1 = require("../../utils/workspace-context");
+const output_1 = require("../../utils/output");
+const path_2 = require("../../utils/path");
+const json_1 = require("./json");
+const to_project_name_1 = require("../../config/to-project-name");
+var nx_json_1 = require("./nx-json");
+Object.defineProperty(exports, "readNxJson", { enumerable: true, get: function () { return nx_json_1.readNxJson; } });
+Object.defineProperty(exports, "updateNxJson", { enumerable: true, get: function () { return nx_json_1.updateNxJson; } });
+/**
+ * Adds project configuration to the Nx workspace.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ * @param projectConfiguration - project configuration
+ * @param standalone - whether the project is configured in workspace.json or not
+ */
+function addProjectConfiguration(tree, projectName, projectConfiguration, standalone = true) {
+    const projectConfigFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json');
+    if (!standalone) {
+        output_1.output.warn({
+            title: 'Nx only supports standalone projects. Setting standalone to false is ignored.',
+        });
+    }
+    if (tree.exists(projectConfigFile)) {
+        throw new Error(`Cannot create a new project ${projectName} at ${projectConfiguration.root}. A project already exists in this directory.`);
+    }
+    delete projectConfiguration.$schema;
+    handleEmptyTargets(projectName, projectConfiguration);
+    (0, json_1.writeJson)(tree, projectConfigFile, {
+        name: projectName,
+        $schema: getRelativeProjectJsonSchemaPath(tree, projectConfiguration),
+        ...projectConfiguration,
+        root: undefined,
+    });
+}
+/**
+ * Updates the configuration of an existing project.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ * @param projectConfiguration - project configuration
+ */
+function updateProjectConfiguration(tree, projectName, projectConfiguration) {
+    if (tree.exists((0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json'))) {
+        updateProjectConfigurationInProjectJson(tree, projectName, projectConfiguration);
+    }
+    else if (tree.exists((0, path_2.joinPathFragments)(projectConfiguration.root, 'package.json'))) {
+        updateProjectConfigurationInPackageJson(tree, projectName, projectConfiguration);
+    }
+    else {
+        throw new Error(`Cannot update Project ${projectName} at ${projectConfiguration.root}. It either doesn't exist yet, or may not use project.json for configuration. Use \`addProjectConfiguration()\` instead if you want to create a new project.`);
+    }
+}
+function updateProjectConfigurationInPackageJson(tree, projectName, projectConfiguration) {
+    const packageJsonFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'package.json');
+    const packageJson = (0, json_1.readJson)(tree, packageJsonFile);
+    projectConfiguration.name = projectName;
+    if (packageJson.name === projectConfiguration.name) {
+        delete projectConfiguration.name;
+    }
+    if (projectConfiguration.targets &&
+        !Object.keys(projectConfiguration.targets).length) {
+        delete projectConfiguration.targets;
+    }
+    packageJson.nx = {
+        ...packageJson.nx,
+        ...projectConfiguration,
+    };
+    // We don't want to ever this since it is inferred
+    delete packageJson.nx.root;
+    // Only set `nx` property in `package.json` if it is a root project (necessary to mark it as Nx project),
+    // or if there are properties to be set. If it is empty, then avoid it so we don't add unnecessary boilerplate.
+    if (projectConfiguration.root === '.' ||
+        Object.keys(packageJson.nx).length > 0) {
+        (0, json_1.writeJson)(tree, packageJsonFile, packageJson);
+    }
+}
+function updateProjectConfigurationInProjectJson(tree, projectName, projectConfiguration) {
+    const projectConfigFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json');
+    handleEmptyTargets(projectName, projectConfiguration);
+    (0, json_1.writeJson)(tree, projectConfigFile, {
+        name: projectConfiguration.name ?? projectName,
+        $schema: getRelativeProjectJsonSchemaPath(tree, projectConfiguration),
+        ...projectConfiguration,
+        root: undefined,
+    });
+}
+/**
+ * Removes the configuration of an existing project.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ */
+function removeProjectConfiguration(tree, projectName) {
+    const projectConfiguration = readProjectConfiguration(tree, projectName);
+    if (!projectConfiguration) {
+        throw new Error(`Cannot delete Project ${projectName}`);
+    }
+    const projectConfigFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json');
+    if (tree.exists(projectConfigFile)) {
+        tree.delete(projectConfigFile);
+    }
+}
+/**
+ * Reads a project configuration.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ * @throws If supplied projectName cannot be found
+ */
+function readProjectConfiguration(tree, projectName) {
+    const allProjects = readAndCombineAllProjectConfigurations(tree);
+    if (!allProjects[projectName]) {
+        // temporary polyfill to make sure our generators work for existing angularcli workspaces
+        if (tree.exists('angular.json')) {
+            const angularJson = toNewFormat((0, json_1.readJson)(tree, 'angular.json'));
+            if (angularJson.projects[projectName])
+                return angularJson.projects[projectName];
+        }
+        throw new Error(`Cannot find configuration for '${projectName}'`);
+    }
+    return allProjects[projectName];
+}
+/**
+ * Get a map of all projects in a workspace.
+ *
+ * Use {@link readProjectConfiguration} if only one project is needed.
+ */
+function getProjects(tree) {
+    let allProjects = readAndCombineAllProjectConfigurations(tree);
+    // temporary polyfill to make sure our generators work for existing angularcli workspaces
+    if (tree.exists('angular.json')) {
+        const angularJson = toNewFormat((0, json_1.readJson)(tree, 'angular.json'));
+        allProjects = { ...allProjects, ...angularJson.projects };
+    }
+    return new Map(Object.keys(allProjects || {}).map((projectName) => {
+        return [projectName, allProjects[projectName]];
+    }));
+}
+function getRelativeProjectJsonSchemaPath(tree, project) {
+    return (0, path_2.normalizePath)((0, path_1.relative)((0, path_1.join)(tree.root, project.root), (0, path_1.join)(tree.root, 'node_modules/nx/schemas/project-schema.json')));
+}
+function readAndCombineAllProjectConfigurations(tree) {
+    /**
+     * We can't update projects that come from plugins anyways, so we are going
+     * to ignore them for now. Plugins should add their own add/create/update methods
+     * if they would like to use devkit to update inferred projects.
+     */
+    const patterns = [
+        '**/project.json',
+        'project.json',
+        ...(0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (p) => (0, json_1.readJson)(tree, p, { expectComments: true }), (p) => {
+            const content = tree.read(p, 'utf-8');
+            const { load } = require('@zkochan/js-yaml');
+            return load(content, { filename: p });
+        }, (p) => tree.exists(p)),
+    ];
+    const globbedFiles = (0, workspace_context_1.globWithWorkspaceContextSync)(tree.root, patterns);
+    const createdFiles = findCreatedProjectFiles(tree, patterns);
+    const deletedFiles = findDeletedProjectFiles(tree, patterns);
+    // Ensure we don't duplicate files that are both globbed and in tree changes
+    const allProjectFiles = new Set([...globbedFiles, ...createdFiles]);
+    const projectFiles = Array.from(allProjectFiles).filter((r) => deletedFiles.indexOf(r) === -1);
+    const rootMap = {};
+    for (const projectFile of projectFiles) {
+        if ((0, path_1.basename)(projectFile) === 'project.json') {
+            const json = (0, json_1.readJson)(tree, projectFile);
+            const config = (0, project_json_1.buildProjectFromProjectJson)(json, projectFile);
+            if (!config.name) {
+                try {
+                    const packageJson = (0, json_1.readJson)(tree, (0, path_2.joinPathFragments)(config.root, 'package.json'));
+                    if (packageJson.name) {
+                        config.name = packageJson.name;
+                    }
+                }
+                catch {
+                    // Maybe no package json, is ok.
+                }
+                config.name ??= (0, to_project_name_1.toProjectName)(projectFile);
+            }
+            (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, config, undefined, undefined, true);
+        }
+        if ((0, path_1.basename)(projectFile) === 'package.json') {
+            const packageJson = (0, json_1.readJson)(tree, projectFile);
+            // We don't want to have all of the extra inferred stuff in here, as
+            // when generators update the project they shouldn't inline that stuff.
+            // so rather than using `buildProjectFromPackageJson` and stripping it out
+            // we are going to build the config manually.
+            const config = {
+                root: (0, path_1.dirname)(projectFile),
+                name: packageJson.name ?? (0, to_project_name_1.toProjectName)(projectFile),
+                ...packageJson.nx,
+            };
+            if (!rootMap[config.root]) {
+                (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, 
+                // Inferred targets, tags, etc don't show up when running generators
+                // This is to help avoid running into issues when trying to update the workspace
+                config, undefined, undefined, true);
+            }
+        }
+    }
+    return (0, project_configuration_utils_1.readProjectConfigurationsFromRootMap)(rootMap);
+}
+/**
+ * Used to ensure that projects created during
+ * the same devkit generator run show up when
+ * there is no project.json file, as `glob`
+ * cannot find them.
+ *
+ * We exclude the root `package.json` from this list unless
+ * considered a project during workspace generation
+ */
+function findCreatedProjectFiles(tree, globPatterns) {
+    const createdProjectFiles = [];
+    for (const change of tree.listChanges()) {
+        // Include both CREATE and UPDATE changes to handle project files
+        // created during generator callbacks (which are marked as UPDATE
+        // since the tree has already been flushed to disk)
+        if (change.type === 'CREATE' || change.type === 'UPDATE') {
+            const fileName = (0, path_1.basename)(change.path);
+            if (globPatterns.some((pattern) => (0, minimatch_1.minimatch)(change.path, pattern, { dot: true }))) {
+                createdProjectFiles.push(change.path);
+            }
+            else if (fileName === 'package.json') {
+                try {
+                    const contents = JSON.parse(change.content.toString());
+                    if (contents.nx) {
+                        createdProjectFiles.push(change.path);
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    return createdProjectFiles.map(path_2.normalizePath);
+}
+/**
+ * Used to ensure that projects created during
+ * the same devkit generator run show up when
+ * there is no project.json file, as `glob`
+ * cannot find them.
+ */
+function findDeletedProjectFiles(tree, globPatterns) {
+    return tree
+        .listChanges()
+        .filter((f) => {
+        return (f.type === 'DELETE' &&
+            globPatterns.some((pattern) => (0, minimatch_1.minimatch)(f.path, pattern)));
+    })
+        .map((r) => r.path);
+}
+function toNewFormat(w) {
+    const projects = {};
+    Object.keys(w.projects || {}).forEach((name) => {
+        if (typeof w.projects[name] === 'string')
+            return;
+        const projectConfig = w.projects[name];
+        if (projectConfig.architect) {
+            (0, angular_json_1.renamePropertyWithStableKeys)(projectConfig, 'architect', 'targets');
+        }
+        if (projectConfig.schematics) {
+            (0, angular_json_1.renamePropertyWithStableKeys)(projectConfig, 'schematics', 'generators');
+        }
+        Object.values(projectConfig.targets || {}).forEach((target) => {
+            if (target.builder !== undefined) {
+                (0, angular_json_1.renamePropertyWithStableKeys)(target, 'builder', 'executor');
+            }
+        });
+        projects[name] = projectConfig;
+    });
+    w.projects = projects;
+    if (w.schematics) {
+        (0, angular_json_1.renamePropertyWithStableKeys)(w, 'schematics', 'generators');
+    }
+    if (w.version !== 2) {
+        w.version = 2;
+    }
+    return w;
+}
+function handleEmptyTargets(projectName, projectConfiguration) {
+    if (projectConfiguration.targets &&
+        !Object.keys(projectConfiguration.targets).length) {
+        // Re-order `targets` to appear after the `// target` comment.
+        delete projectConfiguration.targets;
+        projectConfiguration['// targets'] =
+            `to see all targets run: nx show project ${projectName} --web`;
+        projectConfiguration.targets = {};
+    }
+    else {
+        delete projectConfiguration['// targets'];
+    }
+}

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

@@ -0,0 +1,5 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { TaskHasher } from './task-hasher';
+export declare function createTaskHasher(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, runnerOptions?: any): TaskHasher;
+//# sourceMappingURL=create-task-hasher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-task-hasher.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/hasher/create-task-hasher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAGvD,OAAO,EAGL,UAAU,EACX,MAAM,eAAe,CAAC;AAEvB,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,mBAAmB,EAC3B,aAAa,CAAC,EAAE,GAAG,GAClB,UAAU,CAYZ"}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskHasher = createTaskHasher;
+const client_1 = require("../daemon/client/client");
+const build_project_graph_1 = require("../project-graph/build-project-graph");
+const task_hasher_1 = require("./task-hasher");
+function createTaskHasher(projectGraph, nxJson, runnerOptions) {
+    if (client_1.daemonClient.enabled()) {
+        return new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, runnerOptions);
+    }
+    else {
+        const { fileMap, allWorkspaceFiles, rustReferences } = (0, build_project_graph_1.getFileMap)();
+        return new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, runnerOptions);
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare function hashArray(content: string[]): string;
+export declare function hashObject(obj: object): string;
+export declare function hashFile(filePath: string): string;
+//# sourceMappingURL=file-hasher.d.ts.map

package/src/hasher/file-hasher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-hasher.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/hasher/file-hasher.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAInD;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAU9C;AAED,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAIjD"}

package/src/hasher/file-hasher.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashArray = hashArray;
+exports.hashObject = hashObject;
+exports.hashFile = hashFile;
+function hashArray(content) {
+    // Import as needed. There is also an issue running unit tests in Nx repo if this is a top-level import.
+    const { hashArray } = require('../native');
+    return hashArray(content);
+}
+function hashObject(obj) {
+    const { hashArray } = require('../native');
+    const parts = [];
+    for (const key of Object.keys(obj ?? {}).sort()) {
+        parts.push(key);
+        parts.push(JSON.stringify(obj[key]));
+    }
+    return hashArray(parts);
+}
+function hashFile(filePath) {
+    const { hashFile } = require('../native');
+    return hashFile(filePath);
+}

package/src/hasher/hash-plan-inspector.d.ts

@@ -0,0 +1,26 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import type { Target } from '../command-line/run/run';
+import { TargetDependencies } from '../config/nx-json';
+import { TargetDependencyConfig } from '../config/workspace-json-project-json';
+export declare class HashPlanInspector {
+    private projectGraph;
+    private readonly workspaceRootPath;
+    private readonly projectGraphRef;
+    private planner;
+    private inspector;
+    private readonly nxJson;
+    constructor(projectGraph: ProjectGraph, workspaceRootPath?: string, nxJson?: NxJsonConfiguration);
+    init(): Promise<void>;
+    /**
+     * This is a lower level method which will inspect the hash plan for a set of tasks.
+     */
+    inspectHashPlan(projectNames: string[], targets: string[], configuration?: string, overrides?: Object, extraTargetDependencies?: TargetDependencies, excludeTaskDependencies?: boolean): Record<string, string[]>;
+    /**
+     * This inspects tasks involved in the execution of a task, including its dependencies by default.
+     */
+    inspectTask({ project, target, configuration }: Target, parsedArgs?: {
+        [k: string]: any;
+    }, extraTargetDependencies?: Record<string, (TargetDependencyConfig | string)[]>, excludeTaskDependencies?: boolean): Record<string, string[]>;
+}
+//# sourceMappingURL=hash-plan-inspector.d.ts.map

package/src/hasher/hash-plan-inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-plan-inspector.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/hasher/hash-plan-inspector.ts"],"names":[],"mappings":"AAOA,OAAO,EAAc,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAEpE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAIvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAI/E,qBAAa,iBAAiB;IAO1B,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAPpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAqC;IACrE,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;gBAGnC,YAAY,EAAE,YAAY,EACjB,iBAAiB,GAAE,MAAsB,EAC1D,MAAM,CAAC,EAAE,mBAAmB;IASxB,IAAI;IAeV;;OAEG;IACH,eAAe,CACb,YAAY,EAAE,MAAM,EAAE,EACtB,OAAO,EAAE,MAAM,EAAE,EACjB,aAAa,CAAC,EAAE,MAAM,EACtB,SAAS,GAAE,MAAW,EACtB,uBAAuB,GAAE,kBAAuB,EAChD,uBAAuB,GAAE,OAAe;IAmB1C;;OAEG;IACH,WAAW,CACT,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,MAAM,EAC1C,UAAU,GAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;KAAO,EACrC,uBAAuB,GAAE,MAAM,CAC7B,MAAM,EACN,CAAC,sBAAsB,GAAG,MAAM,CAAC,EAAE,CAC/B,EACN,uBAAuB,GAAE,OAAe;CA+B3C"}

package/src/hasher/hash-plan-inspector.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashPlanInspector = void 0;
+const native_1 = require("../native");
+const nx_json_1 = require("../config/nx-json");
+const transform_objects_1 = require("../native/transform-objects");
+const workspace_root_1 = require("../utils/workspace-root");
+const find_project_for_path_1 = require("../project-graph/utils/find-project-for-path");
+const create_task_graph_1 = require("../tasks-runner/create-task-graph");
+const command_line_utils_1 = require("../utils/command-line-utils");
+const workspace_context_1 = require("../utils/workspace-context");
+class HashPlanInspector {
+    constructor(projectGraph, workspaceRootPath = workspace_root_1.workspaceRoot, nxJson) {
+        this.projectGraph = projectGraph;
+        this.workspaceRootPath = workspaceRootPath;
+        this.nxJson = nxJson ?? (0, nx_json_1.readNxJson)(this.workspaceRootPath);
+        this.projectGraphRef = (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(this.projectGraph));
+        this.planner = new native_1.HashPlanner(this.nxJson, this.projectGraphRef);
+    }
+    async init() {
+        const projectRootMap = (0, find_project_for_path_1.createProjectRootMappings)(this.projectGraph.nodes);
+        const map = Object.fromEntries(projectRootMap.entries());
+        const { externalReferences } = await (0, workspace_context_1.getNxWorkspaceFilesFromContext)(this.workspaceRootPath, map, false);
+        this.inspector = new native_1.HashPlanInspector(externalReferences.allWorkspaceFiles, this.projectGraphRef, externalReferences.projectFiles);
+    }
+    /**
+     * This is a lower level method which will inspect the hash plan for a set of tasks.
+     */
+    inspectHashPlan(projectNames, targets, configuration, overrides = {}, extraTargetDependencies = {}, excludeTaskDependencies = false) {
+        const taskGraph = (0, create_task_graph_1.createTaskGraph)(this.projectGraph, extraTargetDependencies, projectNames, targets, configuration, overrides, excludeTaskDependencies);
+        // Generate task IDs for ALL tasks in the task graph (including dependencies)
+        const taskIds = Object.keys(taskGraph.tasks);
+        const plansReference = this.planner.getPlansReference(taskIds, taskGraph);
+        return this.inspector.inspect(plansReference);
+    }
+    /**
+     * This inspects tasks involved in the execution of a task, including its dependencies by default.
+     */
+    inspectTask({ project, target, configuration }, parsedArgs = {}, extraTargetDependencies = {}, excludeTaskDependencies = false) {
+        // Mirror the exact flow from run-one.ts
+        const { nxArgs, overrides } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)({
+            ...parsedArgs,
+            configuration: configuration,
+            targets: [target],
+        }, 'run-one', { printWarnings: false }, this.nxJson);
+        // Create task graph exactly like run-one.ts does via createTaskGraphAndRunValidations
+        const taskGraph = (0, create_task_graph_1.createTaskGraph)(this.projectGraph, extraTargetDependencies, [project], nxArgs.targets, nxArgs.configuration, overrides, excludeTaskDependencies);
+        // Generate task IDs for ALL tasks in the task graph (including dependencies)
+        const taskIds = Object.keys(taskGraph.tasks);
+        const plansReference = this.planner.getPlansReference(taskIds, taskGraph);
+        return this.inspector.inspect(plansReference);
+    }
+}
+exports.HashPlanInspector = HashPlanInspector;

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

@@ -0,0 +1,10 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { TaskDetails } from '../native';
+import { TaskHasher } from './task-hasher';
+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>;
+export declare function hashTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, taskDetails: TaskDetails | null): Promise<void>;
+//# sourceMappingURL=hash-task.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash-task.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/hasher/hash-task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAc,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAW,WAAW,EAAE,MAAM,WAAW,CAAC;AAKjD,OAAO,EAAa,UAAU,EAAE,MAAM,eAAe,CAAC;AAItD,wBAAgB,cAAc,IAAI,WAAW,GAAG,IAAI,CASnD;AAED,wBAAsB,6CAA6C,CACjE,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,YAAY,EAC1B,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,mBAAmB,EAC3B,YAAY,EAAE,WAAW,GAAG,IAAI,iBAsDjC;AAED,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,YAAY,EAC1B,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,MAAM,CAAC,UAAU,EACtB,WAAW,EAAE,WAAW,GAAG,IAAI,iBA4ChC;AAED,wBAAsB,SAAS,CAC7B,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,YAAY,EAC1B,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,CAAC,UAAU,EACtB,WAAW,EAAE,WAAW,GAAG,IAAI,iBAqFhC"}