@ohos-ports/nx 19.8.4-beta.0

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

@@ -0,0 +1,278 @@
+"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);
+    if (packageJson.name === projectConfiguration.name ?? projectName) {
+        delete projectConfiguration.name;
+    }
+    if (projectConfiguration.targets &&
+        !Object.keys(projectConfiguration.targets).length) {
+        delete projectConfiguration.targets;
+    }
+    packageJson.nx = {
+        ...packageJson.nx,
+        ...projectConfiguration,
+        root: undefined,
+    };
+    (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 })),
+    ];
+    const globbedFiles = (0, workspace_context_1.globWithWorkspaceContextSync)(tree.root, patterns);
+    const createdFiles = findCreatedProjectFiles(tree, patterns);
+    const deletedFiles = findDeletedProjectFiles(tree, patterns);
+    const projectFiles = [...globbedFiles, ...createdFiles].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);
+            (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);
+            // 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()) {
+        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;
+}
+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,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,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(fileMap?.projectFileMap, allWorkspaceFiles, projectGraph, nxJson, rustReferences, runnerOptions);
+    }
+}

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

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

@@ -0,0 +1,8 @@
+import { Task, TaskGraph } from '../config/task-graph';
+import { TaskHasher } from './task-hasher';
+import { ProjectGraph } from '../config/project-graph';
+import { NxJsonConfiguration } from '../config/nx-json';
+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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTaskDetails = getTaskDetails;
+exports.hashTasksThatDoNotDependOnOutputsOfOtherTasks = hashTasksThatDoNotDependOnOutputsOfOtherTasks;
+exports.hashTask = hashTask;
+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");
+const native_1 = require("../native");
+const db_connection_1 = require("../utils/db-connection");
+let taskDetails;
+function getTaskDetails() {
+    // TODO: Remove when wasm supports sqlite
+    if (process.env.NX_DISABLE_DB === 'true' || native_1.IS_WASM) {
+        return null;
+    }
+    if (!taskDetails) {
+        taskDetails = new native_1.TaskDetails((0, db_connection_1.getDbConnection)());
+    }
+    return taskDetails;
+}
+async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson, tasksDetails) {
+    performance.mark('hashMultipleTasks:start');
+    const tasks = Object.values(taskGraph.tasks);
+    const tasksWithHashers = await Promise.all(tasks.map(async (task) => {
+        const customHasher = (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, process.env);
+    for (let i = 0; i < tasksToHash.length; i++) {
+        tasksToHash[i].hash = hashes[i].value;
+        tasksToHash[i].hashDetails = hashes[i].details;
+    }
+    if (tasksDetails?.recordTaskDetails) {
+        tasksDetails.recordTaskDetails(tasksToHash.map((task) => ({
+            hash: task.hash,
+            project: task.target.project,
+            target: task.target.target,
+            configuration: task.target.configuration,
+        })));
+    }
+    performance.mark('hashMultipleTasks:end');
+    performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');
+}
+async function hashTask(hasher, projectGraph, taskGraph, task, env, taskDetails) {
+    performance.mark('hashSingleTask:start');
+    const customHasher = (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;
+    if (taskDetails?.recordTaskDetails) {
+        taskDetails.recordTaskDetails([
+            {
+                hash: task.hash,
+                project: task.target.project,
+                target: task.target.target,
+                configuration: task.target.configuration,
+            },
+        ]);
+    }
+    performance.mark('hashSingleTask:end');
+    performance.measure('hashSingleTask', 'hashSingleTask:start', 'hashSingleTask:end');
+}

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

@@ -0,0 +1,18 @@
+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,48 @@
+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;
+}