@ohos-ports/nx 17.3.2-beta.0

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateNxJson = exports.readNxJson = void 0;
+const path_1 = require("path");
+const json_1 = require("./json");
+const nx_json_1 = require("../../config/nx-json");
+/**
+ * Reads nx.json
+ */
+function readNxJson(tree) {
+    if (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;
+    }
+    else {
+        return (0, nx_json_1.readNxJson)();
+    }
+}
+exports.readNxJson = readNxJson;
+/**
+ * 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;
+            }
+        });
+    }
+}
+exports.updateNxJson = updateNxJson;
+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,42 @@
+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;

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

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelativeProjectJsonSchemaPath = exports.getProjects = exports.readProjectConfiguration = exports.removeProjectConfiguration = exports.updateProjectConfiguration = exports.addProjectConfiguration = exports.updateNxJson = exports.readNxJson = void 0;
+const minimatch_1 = require("minimatch");
+const path_1 = require("path");
+const package_json_workspaces_1 = require("../../plugins/package-json-workspaces");
+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 retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
+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 nx_json_1 = require("./nx-json");
+var nx_json_2 = require("./nx-json");
+Object.defineProperty(exports, "readNxJson", { enumerable: true, get: function () { return nx_json_2.readNxJson; } });
+Object.defineProperty(exports, "updateNxJson", { enumerable: true, get: function () { return nx_json_2.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;
+    (0, json_1.writeJson)(tree, projectConfigFile, {
+        name: projectName,
+        $schema: getRelativeProjectJsonSchemaPath(tree, projectConfiguration),
+        ...projectConfiguration,
+        root: undefined,
+    });
+}
+exports.addProjectConfiguration = addProjectConfiguration;
+/**
+ * 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) {
+    const projectConfigFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json');
+    if (!tree.exists(projectConfigFile)) {
+        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.`);
+    }
+    (0, json_1.writeJson)(tree, projectConfigFile, {
+        name: projectConfiguration.name ?? projectName,
+        $schema: getRelativeProjectJsonSchemaPath(tree, projectConfiguration),
+        ...projectConfiguration,
+        root: undefined,
+    });
+}
+exports.updateProjectConfiguration = updateProjectConfiguration;
+/**
+ * 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);
+    }
+}
+exports.removeProjectConfiguration = removeProjectConfiguration;
+/**
+ * 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];
+}
+exports.readProjectConfiguration = readProjectConfiguration;
+/**
+ * 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]];
+    }));
+}
+exports.getProjects = getProjects;
+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')));
+}
+exports.getRelativeProjectJsonSchemaPath = getRelativeProjectJsonSchemaPath;
+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_workspaces_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (p) => (0, json_1.readJson)(tree, p)),
+    ];
+    const projectGlobPatterns = (0, retrieve_workspace_files_1.configurationGlobs)([
+        { plugin: project_json_1.ProjectJsonProjectsPlugin },
+        { plugin: (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(tree.root) },
+    ]);
+    const globbedFiles = (0, workspace_context_1.globWithWorkspaceContext)(tree.root, projectGlobPatterns);
+    const createdFiles = findCreatedProjectFiles(tree, patterns);
+    const deletedFiles = findDeletedProjectFiles(tree, patterns);
+    const projectFiles = [...globbedFiles, ...createdFiles].filter((r) => deletedFiles.indexOf(r) === -1);
+    const rootMap = new Map();
+    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);
+            (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, config, undefined, undefined, true);
+        }
+        else if ((0, path_1.basename)(projectFile) === 'package.json') {
+            const packageJson = (0, json_1.readJson)(tree, projectFile);
+            const config = (0, package_json_workspaces_1.buildProjectConfigurationFromPackageJson)(packageJson, projectFile, (0, nx_json_1.readNxJson)(tree));
+            if (!rootMap.has(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
+                {
+                    name: config.name,
+                    root: config.root,
+                }, 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()) {
+        if (change.type === 'CREATE') {
+            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;
+}

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

@@ -0,0 +1,4 @@
+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;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskHasher = void 0;
+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(fileMap?.projectFileMap, allWorkspaceFiles, projectGraph, nxJson, rustReferences, runnerOptions);
+    }
+}
+exports.createTaskHasher = createTaskHasher;

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

@@ -0,0 +1,2 @@
+export declare function hashArray(content: string[]): string;
+export declare function hashObject(obj: object): string;

package/src/hasher/file-hasher.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashObject = exports.hashArray = void 0;
+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);
+}
+exports.hashArray = hashArray;
+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);
+}
+exports.hashObject = hashObject;

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

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+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>;

package/src/hasher/hash-task.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashTask = exports.hashTasksThatDoNotDependOnOutputsOfOtherTasks = void 0;
+const utils_1 = require("../tasks-runner/utils");
+const project_graph_1 = require("../project-graph/project-graph");
+const task_hasher_1 = require("./task-hasher");
+const nx_json_1 = require("../config/nx-json");
+async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson) {
+    performance.mark('hashMultipleTasks:start');
+    const tasks = Object.values(taskGraph.tasks);
+    const tasksWithHashers = await Promise.all(tasks.map(async (task) => {
+        const customHasher = await (0, utils_1.getCustomHasher)(task, projectGraph);
+        return { task, customHasher };
+    }));
+    const tasksToHash = tasksWithHashers
+        .filter(({ task, customHasher }) => {
+        // If a task has a custom hasher, it might depend on the outputs of other tasks
+        if (customHasher) {
+            return false;
+        }
+        return !(taskGraph.dependencies[task.id].length > 0 &&
+            (0, task_hasher_1.getInputs)(task, projectGraph, nxJson).depsOutputs.length > 0);
+    })
+        .map((t) => t.task);
+    const hashes = await hasher.hashTasks(tasksToHash, taskGraph);
+    for (let i = 0; i < tasksToHash.length; i++) {
+        tasksToHash[i].hash = hashes[i].value;
+        tasksToHash[i].hashDetails = hashes[i].details;
+    }
+    performance.mark('hashMultipleTasks:end');
+    performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');
+}
+exports.hashTasksThatDoNotDependOnOutputsOfOtherTasks = hashTasksThatDoNotDependOnOutputsOfOtherTasks;
+async function hashTask(hasher, projectGraph, taskGraph, task, env) {
+    performance.mark('hashSingleTask:start');
+    const customHasher = await (0, utils_1.getCustomHasher)(task, projectGraph);
+    const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    const { value, details } = await (customHasher
+        ? customHasher(task, {
+            hasher,
+            projectGraph,
+            taskGraph,
+            workspaceConfig: projectsConfigurations, // to make the change non-breaking. Remove after v19
+            projectsConfigurations,
+            nxJsonConfiguration: (0, nx_json_1.readNxJson)(),
+            env,
+        })
+        : hasher.hashTask(task, taskGraph, env));
+    task.hash = value;
+    task.hashDetails = details;
+    performance.mark('hashSingleTask:end');
+    performance.measure('hashSingleTask', 'hashSingleTask:start', 'hashSingleTask:end');
+}
+exports.hashTask = hashTask;

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

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { ExternalObject, FileData, HasherOptions, HashPlanner, NxWorkspaceFilesExternals, ProjectGraph as NativeProjectGraph, TaskHasher } from '../native';
+import { PartialHash, TaskHasherImpl } from './task-hasher';
+export declare class NativeTaskHasherImpl implements TaskHasherImpl {
+    hasher: TaskHasher;
+    planner: HashPlanner;
+    projectGraphRef: ExternalObject<NativeProjectGraph>;
+    allWorkspaceFilesRef: ExternalObject<FileData[]>;
+    projectFileMapRef: ExternalObject<Record<string, FileData[]>>;
+    options: HasherOptions | undefined;
+    constructor(workspaceRoot: string, nxJson: NxJsonConfiguration, projectGraph: ProjectGraph, externals: NxWorkspaceFilesExternals, options: {
+        selectivelyHashTsConfig: boolean;
+    });
+    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<PartialHash>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<PartialHash[]>;
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeTaskHasherImpl = void 0;
+const native_1 = require("../native");
+const transform_objects_1 = require("../native/transform-objects");
+const fileutils_1 = require("../utils/fileutils");
+const typescript_1 = require("../plugins/js/utils/typescript");
+class NativeTaskHasherImpl {
+    constructor(workspaceRoot, nxJson, projectGraph, externals, options) {
+        this.projectGraphRef = (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(projectGraph));
+        this.allWorkspaceFilesRef = externals.allWorkspaceFiles;
+        this.projectFileMapRef = externals.projectFiles;
+        let tsconfig = {};
+        let paths = {};
+        let rootTsConfigPath = (0, typescript_1.getRootTsConfigPath)();
+        if (rootTsConfigPath) {
+            tsconfig = (0, fileutils_1.readJsonFile)((0, typescript_1.getRootTsConfigPath)());
+            paths = tsconfig.compilerOptions?.paths ?? {};
+            if (tsconfig.compilerOptions?.paths) {
+                delete tsconfig.compilerOptions.paths;
+            }
+        }
+        this.planner = new native_1.HashPlanner(nxJson, this.projectGraphRef);
+        this.hasher = new native_1.TaskHasher(workspaceRoot, this.projectGraphRef, this.projectFileMapRef, this.allWorkspaceFilesRef, Buffer.from(JSON.stringify(tsconfig)), paths, options);
+    }
+    async hashTask(task, taskGraph, env) {
+        const plans = this.planner.getPlansReference([task.id], taskGraph);
+        const hashes = this.hasher.hashPlans(plans, env);
+        return hashes[task.id];
+    }
+    async hashTasks(tasks, taskGraph, env) {
+        const plans = this.planner.getPlansReference(tasks.map((t) => t.id), taskGraph);
+        const hashes = this.hasher.hashPlans(plans, env);
+        return tasks.map((t) => hashes[t.id]);
+    }
+}
+exports.NativeTaskHasherImpl = NativeTaskHasherImpl;

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

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+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 hashRootFileset;
+    private hashProjectConfig;
+    private hashTsConfig;
+    private hashProjectFileset;
+    private hashRuntime;
+    private hashEnv;
+    private calculateExternalDependencyHashes;
+}