@depup/nx 22.5.4-depup.0

package/src/hasher/hash-task.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTaskDetails = getTaskDetails;
+exports.hashTasksThatDoNotDependOnOutputsOfOtherTasks = hashTasksThatDoNotDependOnOutputsOfOtherTasks;
+exports.hashTask = hashTask;
+exports.hashTasks = hashTasks;
+const nx_json_1 = require("../config/nx-json");
+const native_1 = require("../native");
+const project_graph_1 = require("../project-graph/project-graph");
+const task_io_service_1 = require("../tasks-runner/task-io-service");
+const utils_1 = require("../tasks-runner/utils");
+const db_connection_1 = require("../utils/db-connection");
+const task_hasher_1 = require("./task-hasher");
+let taskDetails;
+function getTaskDetails() {
+    // TODO: Remove when wasm supports sqlite
+    if (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 && customHasher.name !== 'eslint-hasher') {
+            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);
+    const ioService = (0, task_io_service_1.getTaskIOService)();
+    for (let i = 0; i < tasksToHash.length; i++) {
+        tasksToHash[i].hash = hashes[i].value;
+        tasksToHash[i].hashDetails = hashes[i].details;
+        // Notify TaskIOService of hash inputs
+        if (hashes[i].inputs) {
+            ioService.notifyTaskInputs(tasksToHash[i].id, hashes[i].inputs);
+        }
+    }
+    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, inputs } = 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;
+    // Notify TaskIOService of hash inputs
+    if (inputs) {
+        (0, task_io_service_1.getTaskIOService)().notifyTaskInputs(task.id, inputs);
+    }
+    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');
+}
+async function hashTasks(hasher, projectGraph, taskGraph, env, taskDetails) {
+    performance.mark('hashMultipleTasks:start');
+    const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    const nxJson = (0, nx_json_1.readNxJson)();
+    const tasks = Object.values(taskGraph.tasks).filter((task) => !task.hash);
+    // Separate tasks with custom hashers from those without
+    const tasksWithCustomHashers = [];
+    const tasksWithoutCustomHashers = [];
+    for (const task of tasks) {
+        const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
+        if (customHasher) {
+            tasksWithCustomHashers.push(task);
+        }
+        else {
+            tasksWithoutCustomHashers.push(task);
+        }
+    }
+    // Hash tasks with custom hashers individually
+    const ioService = (0, task_io_service_1.getTaskIOService)();
+    const customHasherPromises = tasksWithCustomHashers.map(async (task) => {
+        const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
+        const { value, details, inputs } = await customHasher(task, {
+            hasher,
+            projectGraph,
+            taskGraph,
+            workspaceConfig: projectsConfigurations,
+            projectsConfigurations,
+            nxJsonConfiguration: nxJson,
+            env,
+        });
+        task.hash = value;
+        task.hashDetails = details;
+        // Notify TaskIOService of hash inputs
+        if (inputs) {
+            ioService.notifyTaskInputs(task.id, inputs);
+        }
+    });
+    // Hash tasks without custom hashers in batch
+    let batchHashPromise = Promise.resolve();
+    if (tasksWithoutCustomHashers.length > 0) {
+        batchHashPromise = hasher
+            .hashTasks(tasksWithoutCustomHashers, taskGraph, env)
+            .then((hashes) => {
+            for (let i = 0; i < tasksWithoutCustomHashers.length; i++) {
+                tasksWithoutCustomHashers[i].hash = hashes[i].value;
+                tasksWithoutCustomHashers[i].hashDetails = hashes[i].details;
+                // Notify TaskIOService of hash inputs
+                if (hashes[i].inputs) {
+                    ioService.notifyTaskInputs(tasksWithoutCustomHashers[i].id, hashes[i].inputs);
+                }
+            }
+        });
+    }
+    await Promise.all([...customHasherPromises, batchHashPromise]);
+    if (taskDetails?.recordTaskDetails) {
+        taskDetails.recordTaskDetails(tasks.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');
+}

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

@@ -0,0 +1,19 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { ExternalObject, FileData, HasherOptions, HashPlanner, ProjectGraph as NativeProjectGraph, NxWorkspaceFilesExternals, 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, cwd?: string): Promise<PartialHash>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string): Promise<PartialHash[]>;
+}
+//# sourceMappingURL=native-task-hasher-impl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"native-task-hasher-impl.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/hasher/native-task-hasher-impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EACL,cAAc,EACd,QAAQ,EACR,aAAa,EACb,WAAW,EACX,YAAY,IAAI,kBAAkB,EAClC,yBAAyB,EACzB,UAAU,EAEX,MAAM,WAAW,CAAC;AAInB,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE5D,qBAAa,oBAAqB,YAAW,cAAc;IACzD,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,WAAW,CAAC;IACrB,eAAe,EAAE,cAAc,CAAC,kBAAkB,CAAC,CAAC;IACpD,oBAAoB,EAAE,cAAc,CAAC,QAAQ,EAAE,CAAC,CAAC;IACjD,iBAAiB,EAAE,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;IAC9D,OAAO,EAAE,aAAa,GAAG,SAAS,CAAC;gBAGjC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,mBAAmB,EAC3B,YAAY,EAAE,YAAY,EAC1B,SAAS,EAAE,yBAAyB,EACpC,OAAO,EAAE;QAAE,uBAAuB,EAAE,OAAO,CAAA;KAAE;IAkCzC,QAAQ,CACZ,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,CAAC,UAAU,EACtB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,WAAW,CAAC;IAOjB,SAAS,CACb,KAAK,EAAE,IAAI,EAAE,EACb,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,CAAC,UAAU,EACtB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,WAAW,EAAE,CAAC;CAQ1B"}

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 typescript_1 = require("../plugins/js/utils/typescript");
+const fileutils_1 = require("../utils/fileutils");
+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, rootTsConfigPath, options);
+    }
+    async hashTask(task, taskGraph, env, cwd) {
+        const plans = this.planner.getPlansReference([task.id], taskGraph);
+        const hashes = this.hasher.hashPlans(plans, env, cwd ?? process.cwd());
+        return hashes[task.id];
+    }
+    async hashTasks(tasks, taskGraph, env, cwd) {
+        const plans = this.planner.getPlansReference(tasks.map((t) => t.id), taskGraph);
+        const hashes = this.hasher.hashPlans(plans, env, cwd ?? process.cwd());
+        return tasks.map((t) => hashes[t.id]);
+    }
+}
+exports.NativeTaskHasherImpl = NativeTaskHasherImpl;

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

@@ -0,0 +1,128 @@
+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';
+import { InputDefinition } from '../config/workspace-json-project-json';
+import { HashInputs, NxWorkspaceFilesExternals } from '../native';
+export { HashInputs };
+/**
+ * A data structure returned by the default hasher.
+ */
+export interface PartialHash {
+    value: string;
+    details: {
+        [name: string]: string;
+    };
+    inputs: HashInputs;
+}
+/**
+ * A data structure returned by the default hasher.
+ */
+export interface Hash {
+    value: string;
+    details: {
+        command: string;
+        nodes: {
+            [name: string]: string;
+        };
+        implicitDeps?: {
+            [fileName: string]: string;
+        };
+        runtime?: {
+            [input: string]: string;
+        };
+    };
+    inputs?: HashInputs;
+}
+export interface TaskHasher {
+    /**
+     * @deprecated use hashTask(task:Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
+     * @param task
+     */
+    hashTask(task: Task): Promise<Hash>;
+    /**
+     * @deprecated use hashTask(task:Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
+     */
+    hashTask(task: Task, taskGraph: TaskGraph): Promise<Hash>;
+    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string): Promise<Hash>;
+    /**
+     *  @deprecated use hashTasks(tasks:Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
+     * @param tasks
+     */
+    hashTasks(tasks: Task[]): Promise<Hash[]>;
+    /**
+     * @deprecated use hashTasks(tasks:Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
+     */
+    hashTasks(tasks: Task[], taskGraph: TaskGraph): Promise<Hash[]>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string): Promise<Hash[]>;
+}
+export interface TaskHasherImpl {
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string): Promise<PartialHash[]>;
+    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string): Promise<PartialHash>;
+}
+export type Hasher = TaskHasher;
+export declare class DaemonBasedTaskHasher implements TaskHasher {
+    private readonly daemonClient;
+    private readonly runnerOptions;
+    constructor(daemonClient: DaemonClient, runnerOptions: any);
+    hashTasks(tasks: Task[], taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv): Promise<Hash[]>;
+    hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv): Promise<Hash>;
+}
+export declare class InProcessTaskHasher implements TaskHasher {
+    private readonly projectGraph;
+    private readonly nxJson;
+    private readonly externalRustReferences;
+    private readonly options;
+    private taskHasher;
+    constructor(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, externalRustReferences: NxWorkspaceFilesExternals | null, options: any);
+    hashTasks(tasks: Task[], taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv, cwd?: string): Promise<Hash[]>;
+    hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv, cwd?: string): Promise<Hash>;
+    private createHashDetails;
+    private hashCommand;
+}
+export type ExpandedSelfInput = {
+    fileset: string;
+} | {
+    runtime: string;
+} | {
+    env: string;
+} | {
+    externalDependencies: string[];
+};
+export type ExpandedDepsOutput = {
+    dependentTasksOutputFiles: string;
+    transitive?: boolean;
+};
+export type ExpandedInput = ExpandedSelfInput | ExpandedDepsOutput;
+export declare function getNamedInputs(nxJson: NxJsonConfiguration, project: ProjectGraphProjectNode): {
+    default: {
+        fileset: string;
+    }[];
+};
+export declare function getTargetInputs(nxJson: NxJsonConfiguration, projectNode: ProjectGraphProjectNode, target: string): {
+    selfInputs: string[];
+    dependencyInputs: string[];
+};
+export declare function extractPatternsFromFileSets(inputs: readonly ExpandedInput[]): string[];
+export declare function getInputs(task: Task, projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): {
+    selfInputs: ExpandedSelfInput[];
+    depsInputs: {
+        input: string;
+        dependencies: true;
+    }[];
+    depsOutputs: ExpandedDepsOutput[];
+    projectInputs: {
+        input: string;
+        projects: string[];
+    }[];
+};
+export declare function isSelfInput(input: ExpandedInput): input is ExpandedSelfInput;
+export declare function isDepsOutput(input: ExpandedInput): input is ExpandedDepsOutput;
+export declare function expandSingleProjectInputs(inputs: ReadonlyArray<InputDefinition | string>, namedInputs: {
+    [inputName: string]: ReadonlyArray<InputDefinition | string>;
+}): ExpandedInput[];
+export declare function expandNamedInput(input: string, namedInputs: {
+    [inputName: string]: ReadonlyArray<InputDefinition | string>;
+}): ExpandedInput[];
+export declare function filterUsingGlobPatterns(root: string, files: FileData[], patterns: string[]): FileData[];
+//# sourceMappingURL=task-hasher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"task-hasher.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/hasher/task-hasher.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,uBAAuB,EACxB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAIxE,OAAO,EAAE,UAAU,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAGlE,OAAO,EAAE,UAAU,EAAE,CAAC;AAEtB;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE;QACP,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;KACxB,CAAC;IACF,MAAM,EAAE,UAAU,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE;QACP,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE;YAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,CAAC;QAClC,YAAY,CAAC,EAAE;YAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,CAAC;QAC9C,OAAO,CAAC,EAAE;YAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,CAAC;KACvC,CAAC;IACF,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1D,QAAQ,CACN,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,CAAC,UAAU,EACtB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IAE1C;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IAEhE,SAAS,CACP,KAAK,EAAE,IAAI,EAAE,EACb,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,CAAC,UAAU,EACtB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,CACP,KAAK,EAAE,IAAI,EAAE,EACb,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,CAAC,UAAU,EACtB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAE1B,QAAQ,CACN,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,CAAC,UAAU,EACtB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,WAAW,CAAC,CAAC;CACzB;AAED,MAAM,MAAM,MAAM,GAAG,UAAU,CAAC;AAEhC,qBAAa,qBAAsB,YAAW,UAAU;IAEpD,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa;gBADb,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,GAAG;IAG/B,SAAS,CACb,KAAK,EAAE,IAAI,EAAE,EACb,SAAS,CAAC,EAAE,SAAS,EACrB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,GACtB,OAAO,CAAC,IAAI,EAAE,CAAC;IAUZ,QAAQ,CACZ,IAAI,EAAE,IAAI,EACV,SAAS,CAAC,EAAE,SAAS,EACrB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,GACtB,OAAO,CAAC,IAAI,CAAC;CAWjB;AAED,qBAAa,mBAAoB,YAAW,UAAU;IAIlD,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,sBAAsB;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAN1B,OAAO,CAAC,UAAU,CAAiB;gBAGhB,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,mBAAmB,EAC3B,sBAAsB,EAAE,yBAAyB,GAAG,IAAI,EACxD,OAAO,EAAE,GAAG;IAazB,SAAS,CACb,KAAK,EAAE,IAAI,EAAE,EACb,SAAS,CAAC,EAAE,SAAS,EACrB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,EACvB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,EAAE,CAAC;IAYZ,QAAQ,CACZ,IAAI,EAAE,IAAI,EACV,SAAS,CAAC,EAAE,SAAS,EACrB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,EACvB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC;IAUhB,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,WAAW;CAepB;AAED,MAAM,MAAM,iBAAiB,GACzB;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GACnB;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GACnB;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GACf;IAAE,oBAAoB,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AACvC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,yBAAyB,EAAE,MAAM,CAAC;IAClC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,iBAAiB,GAAG,kBAAkB,CAAC;AAWnE,wBAAgB,cAAc,CAC5B,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,uBAAuB;;;;EAOjC;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,mBAAmB,EAC3B,WAAW,EAAE,uBAAuB,EACpC,MAAM,EAAE,MAAM;;;EAmBf;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,SAAS,aAAa,EAAE,GAC/B,MAAM,EAAE,CAIV;AAED,wBAAgB,SAAS,CACvB,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,mBAAmB;;;eAkBN,MAAM;sBAAgB,IAAI;;;;eACvB,MAAM;kBAAY,MAAM,EAAE;;EAPnD;AAyDD,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,GAAG,KAAK,IAAI,iBAAiB,CAE5E;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,aAAa,GACnB,KAAK,IAAI,kBAAkB,CAE7B;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,aAAa,CAAC,eAAe,GAAG,MAAM,CAAC,EAC/C,WAAW,EAAE;IAAE,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,CAAC,eAAe,GAAG,MAAM,CAAC,CAAA;CAAE,GAC5E,aAAa,EAAE,CAiCjB;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,WAAW,EAAE;IAAE,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,CAAC,eAAe,GAAG,MAAM,CAAC,CAAA;CAAE,GAC5E,aAAa,EAAE,CAIjB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,QAAQ,EAAE,EACjB,QAAQ,EAAE,MAAM,EAAE,GACjB,QAAQ,EAAE,CAuCZ"}

package/src/hasher/task-hasher.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InProcessTaskHasher = exports.DaemonBasedTaskHasher = void 0;
+exports.getNamedInputs = getNamedInputs;
+exports.getTargetInputs = getTargetInputs;
+exports.extractPatternsFromFileSets = extractPatternsFromFileSets;
+exports.getInputs = getInputs;
+exports.isSelfInput = isSelfInput;
+exports.isDepsOutput = isDepsOutput;
+exports.expandSingleProjectInputs = expandSingleProjectInputs;
+exports.expandNamedInput = expandNamedInput;
+exports.filterUsingGlobPatterns = filterUsingGlobPatterns;
+const file_hasher_1 = require("./file-hasher");
+const minimatch_1 = require("minimatch");
+const native_task_hasher_impl_1 = require("./native-task-hasher-impl");
+const workspace_root_1 = require("../utils/workspace-root");
+class DaemonBasedTaskHasher {
+    constructor(daemonClient, runnerOptions) {
+        this.daemonClient = daemonClient;
+        this.runnerOptions = runnerOptions;
+    }
+    async hashTasks(tasks, taskGraph, env) {
+        return this.daemonClient.hashTasks(this.runnerOptions, tasks, taskGraph, env ?? process.env, process.cwd());
+    }
+    async hashTask(task, taskGraph, env) {
+        return (await this.daemonClient.hashTasks(this.runnerOptions, [task], taskGraph, env ?? process.env, process.cwd()))[0];
+    }
+}
+exports.DaemonBasedTaskHasher = DaemonBasedTaskHasher;
+class InProcessTaskHasher {
+    constructor(projectGraph, nxJson, externalRustReferences, options) {
+        this.projectGraph = projectGraph;
+        this.nxJson = nxJson;
+        this.externalRustReferences = externalRustReferences;
+        this.options = options;
+        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, cwd) {
+        const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, env ?? process.env, cwd ?? process.cwd());
+        return tasks.map((task, index) => this.createHashDetails(task, hashes[index]));
+    }
+    async hashTask(task, taskGraph, env, cwd) {
+        const res = await this.taskHasher.hashTask(task, taskGraph, env ?? process.env, cwd ?? process.cwd());
+        return this.createHashDetails(task, res);
+    }
+    createHashDetails(task, res) {
+        const command = this.hashCommand(task);
+        return {
+            value: (0, file_hasher_1.hashArray)([res.value, command]),
+            details: {
+                command,
+                nodes: res.details,
+                implicitDeps: {},
+                runtime: {},
+            },
+            inputs: res.inputs,
+        };
+    }
+    hashCommand(task) {
+        const overrides = { ...task.overrides };
+        delete overrides['__overrides_unparsed__'];
+        const sortedOverrides = {};
+        for (let k of Object.keys(overrides).sort()) {
+            sortedOverrides[k] = overrides[k];
+        }
+        return (0, file_hasher_1.hashArray)([
+            task.target.project ?? '',
+            task.target.target ?? '',
+            task.target.configuration ?? '',
+            JSON.stringify(sortedOverrides),
+        ]);
+    }
+}
+exports.InProcessTaskHasher = InProcessTaskHasher;
+const DEFAULT_INPUTS = [
+    {
+        input: 'default',
+    },
+    {
+        dependencies: true,
+        input: 'default',
+    },
+];
+function getNamedInputs(nxJson, project) {
+    return {
+        default: [{ fileset: '{projectRoot}/**/*' }],
+        ...nxJson.namedInputs,
+        ...project.data.namedInputs,
+    };
+}
+function getTargetInputs(nxJson, projectNode, target) {
+    const namedInputs = getNamedInputs(nxJson, projectNode);
+    const targetData = projectNode.data.targets[target];
+    const targetDefaults = (nxJson.targetDefaults || {})[target];
+    const inputs = splitInputsIntoSelfAndDependencies(targetData.inputs || targetDefaults?.inputs || DEFAULT_INPUTS, namedInputs);
+    const selfInputs = extractPatternsFromFileSets(inputs.selfInputs);
+    const dependencyInputs = extractPatternsFromFileSets(inputs.depsInputs.map((s) => expandNamedInput(s.input, namedInputs)).flat());
+    return { selfInputs, dependencyInputs };
+}
+function extractPatternsFromFileSets(inputs) {
+    return inputs
+        .filter((c) => !!c['fileset'])
+        .map((c) => c['fileset']);
+}
+function getInputs(task, projectGraph, nxJson) {
+    const projectNode = projectGraph.nodes[task.target.project];
+    const namedInputs = getNamedInputs(nxJson, projectNode);
+    const targetData = projectNode.data.targets[task.target.target];
+    const targetDefaults = (nxJson.targetDefaults || {})[task.target.target];
+    const { selfInputs, depsInputs, depsOutputs, projectInputs } = splitInputsIntoSelfAndDependencies(targetData.inputs || targetDefaults?.inputs || DEFAULT_INPUTS, namedInputs);
+    return { selfInputs, depsInputs, depsOutputs, projectInputs };
+}
+function splitInputsIntoSelfAndDependencies(inputs, namedInputs) {
+    const depsInputs = [];
+    const projectInputs = [];
+    const selfInputs = [];
+    for (const d of inputs) {
+        if (typeof d === 'string') {
+            if (d.startsWith('^')) {
+                depsInputs.push({ input: d.substring(1), dependencies: true });
+            }
+            else {
+                selfInputs.push(d);
+            }
+        }
+        else {
+            if (('dependencies' in d && d.dependencies) ||
+                // Todo(@AgentEnder): Remove check in v17
+                ('projects' in d &&
+                    typeof d.projects === 'string' &&
+                    d.projects === 'dependencies')) {
+                depsInputs.push({
+                    input: d.input,
+                    dependencies: true,
+                });
+            }
+            else if ('projects' in d &&
+                d.projects &&
+                // Todo(@AgentEnder): Remove check in v17
+                !(d.projects === 'self')) {
+                projectInputs.push({
+                    input: d.input,
+                    projects: Array.isArray(d.projects) ? d.projects : [d.projects],
+                });
+            }
+            else {
+                selfInputs.push(d);
+            }
+        }
+    }
+    const expandedInputs = expandSingleProjectInputs(selfInputs, namedInputs);
+    return {
+        depsInputs,
+        projectInputs,
+        selfInputs: expandedInputs.filter(isSelfInput),
+        depsOutputs: expandedInputs.filter(isDepsOutput),
+    };
+}
+function isSelfInput(input) {
+    return !('dependentTasksOutputFiles' in input);
+}
+function isDepsOutput(input) {
+    return 'dependentTasksOutputFiles' in input;
+}
+function expandSingleProjectInputs(inputs, namedInputs) {
+    const expanded = [];
+    for (const d of inputs) {
+        if (typeof d === 'string') {
+            if (d.startsWith('^'))
+                throw new Error(`namedInputs definitions cannot start with ^`);
+            if (namedInputs[d]) {
+                expanded.push(...expandNamedInput(d, namedInputs));
+            }
+            else {
+                expanded.push({ fileset: d });
+            }
+        }
+        else {
+            if (d.projects || d.dependencies) {
+                throw new Error(`namedInputs definitions can only refer to other namedInputs definitions within the same project.`);
+            }
+            if (d.fileset ||
+                d.env ||
+                d.runtime ||
+                d.externalDependencies ||
+                d.dependentTasksOutputFiles ||
+                d.workingDirectory) {
+                expanded.push(d);
+            }
+            else {
+                expanded.push(...expandNamedInput(d.input, namedInputs));
+            }
+        }
+    }
+    return expanded;
+}
+function expandNamedInput(input, namedInputs) {
+    namedInputs ||= {};
+    if (!namedInputs[input])
+        throw new Error(`Input '${input}' is not defined`);
+    return expandSingleProjectInputs(namedInputs[input], namedInputs);
+}
+function filterUsingGlobPatterns(root, files, patterns) {
+    const filesetWithExpandedProjectRoot = patterns
+        .map((f) => f.replace('{projectRoot}', root))
+        .map((r) => {
+        // handling root level projects that create './' pattern that doesn't work with minimatch
+        if (r.startsWith('./'))
+            return r.substring(2);
+        if (r.startsWith('!./'))
+            return '!' + r.substring(3);
+        return r;
+    });
+    const positive = [];
+    const negative = [];
+    for (const p of filesetWithExpandedProjectRoot) {
+        if (p.startsWith('!')) {
+            negative.push(p);
+        }
+        else {
+            positive.push(p);
+        }
+    }
+    if (positive.length === 0 && negative.length === 0) {
+        return files;
+    }
+    return files.filter((f) => {
+        let matchedPositive = false;
+        if (positive.length === 0 ||
+            (positive.length === 1 && positive[0] === `${root}/**/*`)) {
+            matchedPositive = true;
+        }
+        else {
+            matchedPositive = positive.some((pattern) => (0, minimatch_1.minimatch)(f.file, pattern));
+        }
+        if (!matchedPositive)
+            return false;
+        return negative.every((pattern) => (0, minimatch_1.minimatch)(f.file, pattern));
+    });
+}

package/src/index.d.ts

@@ -0,0 +1,2 @@
+export { initTasksRunner } from './tasks-runner/init-tasks-runner';
+//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/nx/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC"}

package/src/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTasksRunner = void 0;
+var init_tasks_runner_1 = require("./tasks-runner/init-tasks-runner");
+Object.defineProperty(exports, "initTasksRunner", { enumerable: true, get: function () { return init_tasks_runner_1.initTasksRunner; } });

package/src/migrations/update-15-0-0/prefix-outputs.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '../../generators/tree';
+export default function (tree: Tree): Promise<void>;
+//# sourceMappingURL=prefix-outputs.d.ts.map

package/src/migrations/update-15-0-0/prefix-outputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefix-outputs.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/migrations/update-15-0-0/prefix-outputs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAgB7C,yBAA+B,IAAI,EAAE,IAAI,iBAoDxC"}