@ohos-ports/nx 19.8.4-beta.0

package/src/daemon/message-types/get-nx-workspace-files.d.ts

@@ -0,0 +1,6 @@
+export declare const GET_NX_WORKSPACE_FILES: "GET_NX_WORKSPACE_FILES";
+export type HandleNxWorkspaceFilesMessage = {
+    type: typeof GET_NX_WORKSPACE_FILES;
+    projectRootMap: Record<string, string>;
+};
+export declare function isHandleNxWorkspaceFilesMessage(message: unknown): message is HandleNxWorkspaceFilesMessage;

package/src/daemon/message-types/get-nx-workspace-files.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET_NX_WORKSPACE_FILES = void 0;
+exports.isHandleNxWorkspaceFilesMessage = isHandleNxWorkspaceFilesMessage;
+exports.GET_NX_WORKSPACE_FILES = 'GET_NX_WORKSPACE_FILES';
+function isHandleNxWorkspaceFilesMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.GET_NX_WORKSPACE_FILES);
+}

package/src/daemon/message-types/get-registered-sync-generators.d.ts

@@ -0,0 +1,5 @@
+export declare const GET_REGISTERED_SYNC_GENERATORS: "GET_REGISTERED_SYNC_GENERATORS";
+export type HandleGetRegisteredSyncGeneratorsMessage = {
+    type: typeof GET_REGISTERED_SYNC_GENERATORS;
+};
+export declare function isHandleGetRegisteredSyncGeneratorsMessage(message: unknown): message is HandleGetRegisteredSyncGeneratorsMessage;

package/src/daemon/message-types/get-registered-sync-generators.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET_REGISTERED_SYNC_GENERATORS = void 0;
+exports.isHandleGetRegisteredSyncGeneratorsMessage = isHandleGetRegisteredSyncGeneratorsMessage;
+exports.GET_REGISTERED_SYNC_GENERATORS = 'GET_REGISTERED_SYNC_GENERATORS';
+function isHandleGetRegisteredSyncGeneratorsMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.GET_REGISTERED_SYNC_GENERATORS);
+}

package/src/daemon/message-types/get-sync-generator-changes.d.ts

@@ -0,0 +1,6 @@
+export declare const GET_SYNC_GENERATOR_CHANGES: "GET_SYNC_GENERATOR_CHANGES";
+export type HandleGetSyncGeneratorChangesMessage = {
+    type: typeof GET_SYNC_GENERATOR_CHANGES;
+    generators: string[];
+};
+export declare function isHandleGetSyncGeneratorChangesMessage(message: unknown): message is HandleGetSyncGeneratorChangesMessage;

package/src/daemon/message-types/get-sync-generator-changes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET_SYNC_GENERATOR_CHANGES = void 0;
+exports.isHandleGetSyncGeneratorChangesMessage = isHandleGetSyncGeneratorChangesMessage;
+exports.GET_SYNC_GENERATOR_CHANGES = 'GET_SYNC_GENERATOR_CHANGES';
+function isHandleGetSyncGeneratorChangesMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.GET_SYNC_GENERATOR_CHANGES);
+}

package/src/daemon/message-types/glob.d.ts

@@ -0,0 +1,7 @@
+export declare const GLOB: "GLOB";
+export type HandleGlobMessage = {
+    type: typeof GLOB;
+    globs: string[];
+    exclude?: string[];
+};
+export declare function isHandleGlobMessage(message: unknown): message is HandleGlobMessage;

package/src/daemon/message-types/glob.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLOB = void 0;
+exports.isHandleGlobMessage = isHandleGlobMessage;
+exports.GLOB = 'GLOB';
+function isHandleGlobMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.GLOB);
+}

package/src/daemon/message-types/hash-glob.d.ts

@@ -0,0 +1,7 @@
+export declare const HASH_GLOB: "HASH_GLOB";
+export type HandleHashGlobMessage = {
+    type: typeof HASH_GLOB;
+    globs: string[];
+    exclude?: string[];
+};
+export declare function isHandleHashGlobMessage(message: unknown): message is HandleHashGlobMessage;

package/src/daemon/message-types/hash-glob.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HASH_GLOB = void 0;
+exports.isHandleHashGlobMessage = isHandleHashGlobMessage;
+exports.HASH_GLOB = 'HASH_GLOB';
+function isHandleHashGlobMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.HASH_GLOB);
+}

package/src/daemon/message-types/task-history.d.ts

@@ -0,0 +1,19 @@
+import type { TaskRun, TaskTarget } from '../../native';
+export declare const GET_FLAKY_TASKS: "GET_FLAKY_TASKS";
+export declare const GET_ESTIMATED_TASK_TIMINGS: "GET_ESTIMATED_TASK_TIMINGS";
+export declare const RECORD_TASK_RUNS: "RECORD_TASK_RUNS";
+export type HandleGetFlakyTasks = {
+    type: typeof GET_FLAKY_TASKS;
+    hashes: string[];
+};
+export type HandleGetEstimatedTaskTimings = {
+    type: typeof GET_ESTIMATED_TASK_TIMINGS;
+    targets: TaskTarget[];
+};
+export type HandleRecordTaskRunsMessage = {
+    type: typeof RECORD_TASK_RUNS;
+    taskRuns: TaskRun[];
+};
+export declare function isHandleGetFlakyTasksMessage(message: unknown): message is HandleGetFlakyTasks;
+export declare function isHandleGetEstimatedTaskTimings(message: unknown): message is HandleGetEstimatedTaskTimings;
+export declare function isHandleWriteTaskRunsToHistoryMessage(message: unknown): message is HandleRecordTaskRunsMessage;

package/src/daemon/message-types/task-history.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECORD_TASK_RUNS = exports.GET_ESTIMATED_TASK_TIMINGS = exports.GET_FLAKY_TASKS = void 0;
+exports.isHandleGetFlakyTasksMessage = isHandleGetFlakyTasksMessage;
+exports.isHandleGetEstimatedTaskTimings = isHandleGetEstimatedTaskTimings;
+exports.isHandleWriteTaskRunsToHistoryMessage = isHandleWriteTaskRunsToHistoryMessage;
+exports.GET_FLAKY_TASKS = 'GET_FLAKY_TASKS';
+exports.GET_ESTIMATED_TASK_TIMINGS = 'GET_ESTIMATED_TASK_TIMINGS';
+exports.RECORD_TASK_RUNS = 'RECORD_TASK_RUNS';
+function isHandleGetFlakyTasksMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.GET_FLAKY_TASKS);
+}
+function isHandleGetEstimatedTaskTimings(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.GET_ESTIMATED_TASK_TIMINGS);
+}
+function isHandleWriteTaskRunsToHistoryMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.RECORD_TASK_RUNS);
+}

package/src/daemon/message-types/update-workspace-context.d.ts

@@ -0,0 +1,8 @@
+export declare const UPDATE_WORKSPACE_CONTEXT: "UPDATE_WORKSPACE_CONTEXT";
+export type HandleUpdateWorkspaceContextMessage = {
+    type: typeof UPDATE_WORKSPACE_CONTEXT;
+    createdFiles: string[];
+    updatedFiles: string[];
+    deletedFiles: string[];
+};
+export declare function isHandleUpdateWorkspaceContextMessage(message: unknown): message is HandleUpdateWorkspaceContextMessage;

package/src/daemon/message-types/update-workspace-context.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UPDATE_WORKSPACE_CONTEXT = void 0;
+exports.isHandleUpdateWorkspaceContextMessage = isHandleUpdateWorkspaceContextMessage;
+exports.UPDATE_WORKSPACE_CONTEXT = 'UPDATE_WORKSPACE_CONTEXT';
+function isHandleUpdateWorkspaceContextMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.UPDATE_WORKSPACE_CONTEXT);
+}

package/src/daemon/server/file-watching/changed-projects.d.ts

@@ -0,0 +1,10 @@
+export type ChangedFile = {
+    path: string;
+    type: 'create' | 'update' | 'delete';
+};
+export declare function getProjectsAndGlobalChanges(createdFiles: string[] | null, updatedFiles: string[] | null, deletedFiles: string[] | null): {
+    projects: {
+        [changedProject: string]: ChangedFile[];
+    };
+    globalFiles: ChangedFile[];
+};

package/src/daemon/server/file-watching/changed-projects.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectsAndGlobalChanges = getProjectsAndGlobalChanges;
+const perf_hooks_1 = require("perf_hooks");
+const project_graph_incremental_recomputation_1 = require("../project-graph-incremental-recomputation");
+function getProjectsAndGlobalChanges(createdFiles, updatedFiles, deletedFiles) {
+    const projectAndGlobalChanges = {
+        projects: {},
+        globalFiles: [],
+    };
+    perf_hooks_1.performance.mark('changed-projects:start');
+    const allChangedFiles = [
+        ...(createdFiles ?? []).map((c) => ({
+            path: c,
+            type: 'create',
+        })),
+        ...(updatedFiles ?? []).map((c) => ({
+            path: c,
+            type: 'update',
+        })),
+        ...(deletedFiles ?? []).map((c) => ({
+            path: c,
+            type: 'delete',
+        })),
+    ];
+    const fileToProjectMap = {};
+    for (const [projectName, projectFiles] of Object.entries(project_graph_incremental_recomputation_1.fileMapWithFiles?.fileMap?.projectFileMap ?? {})) {
+        for (const projectFile of projectFiles) {
+            fileToProjectMap[projectFile.file] = projectName;
+        }
+    }
+    for (const changedFile of allChangedFiles) {
+        const project = fileToProjectMap[changedFile.path];
+        if (project) {
+            (projectAndGlobalChanges.projects[project] ??= []).push(changedFile);
+        }
+        else {
+            projectAndGlobalChanges.globalFiles.push(changedFile);
+        }
+    }
+    perf_hooks_1.performance.mark('changed-projects:end');
+    perf_hooks_1.performance.measure('changed-projects', 'changed-projects:start', 'changed-projects:end');
+    return projectAndGlobalChanges;
+}

package/src/daemon/server/file-watching/file-watcher-sockets.d.ts

@@ -0,0 +1,12 @@
+import { Socket } from 'net';
+export declare let registeredFileWatcherSockets: {
+    socket: Socket;
+    config: {
+        watchProjects: string[] | 'all';
+        includeGlobalWorkspaceFiles: boolean;
+        includeDependentProjects: boolean;
+    };
+}[];
+export declare function removeRegisteredFileWatcherSocket(socket: Socket): void;
+export declare function hasRegisteredFileWatcherSockets(): boolean;
+export declare function notifyFileWatcherSockets(createdFiles: string[] | null, updatedFiles: string[], deletedFiles: string[]): void;

package/src/daemon/server/file-watching/file-watcher-sockets.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registeredFileWatcherSockets = void 0;
+exports.removeRegisteredFileWatcherSocket = removeRegisteredFileWatcherSocket;
+exports.hasRegisteredFileWatcherSockets = hasRegisteredFileWatcherSockets;
+exports.notifyFileWatcherSockets = notifyFileWatcherSockets;
+const find_matching_projects_1 = require("../../../utils/find-matching-projects");
+const project_graph_utils_1 = require("../../../utils/project-graph-utils");
+const promised_based_queue_1 = require("../../../utils/promised-based-queue");
+const project_graph_incremental_recomputation_1 = require("../project-graph-incremental-recomputation");
+const server_1 = require("../server");
+const changed_projects_1 = require("./changed-projects");
+const queue = new promised_based_queue_1.PromisedBasedQueue();
+exports.registeredFileWatcherSockets = [];
+function removeRegisteredFileWatcherSocket(socket) {
+    exports.registeredFileWatcherSockets = exports.registeredFileWatcherSockets.filter((watcher) => watcher.socket !== socket);
+}
+function hasRegisteredFileWatcherSockets() {
+    return exports.registeredFileWatcherSockets.length > 0;
+}
+function notifyFileWatcherSockets(createdFiles, updatedFiles, deletedFiles) {
+    if (!hasRegisteredFileWatcherSockets()) {
+        return;
+    }
+    queue.sendToQueue(async () => {
+        const projectAndGlobalChanges = (0, changed_projects_1.getProjectsAndGlobalChanges)(createdFiles, updatedFiles, deletedFiles);
+        await Promise.all(exports.registeredFileWatcherSockets.map(({ socket, config }) => {
+            const changedProjects = [];
+            const changedFiles = [];
+            if (config.watchProjects === 'all') {
+                for (const [projectName, projectFiles] of Object.entries(projectAndGlobalChanges.projects)) {
+                    changedProjects.push(projectName);
+                    changedFiles.push(...projectFiles);
+                }
+            }
+            else {
+                const watchedProjects = new Set((0, find_matching_projects_1.findMatchingProjects)(config.watchProjects, project_graph_incremental_recomputation_1.currentProjectGraph.nodes));
+                if (config.includeDependentProjects) {
+                    for (const project of watchedProjects) {
+                        for (const dep of (0, project_graph_utils_1.findAllProjectNodeDependencies)(project, project_graph_incremental_recomputation_1.currentProjectGraph)) {
+                            watchedProjects.add(dep);
+                        }
+                    }
+                }
+                for (const watchedProject of watchedProjects) {
+                    if (!!projectAndGlobalChanges.projects[watchedProject]) {
+                        changedProjects.push(watchedProject);
+                        changedFiles.push(...projectAndGlobalChanges.projects[watchedProject]);
+                    }
+                }
+            }
+            if (config.includeGlobalWorkspaceFiles) {
+                changedFiles.push(...projectAndGlobalChanges.globalFiles);
+            }
+            if (changedProjects.length > 0 || changedFiles.length > 0) {
+                return (0, server_1.handleResult)(socket, 'FILE-WATCH-CHANGED', () => Promise.resolve({
+                    description: 'File watch changed',
+                    response: JSON.stringify({
+                        changedProjects,
+                        changedFiles,
+                    }),
+                }));
+            }
+        }));
+    });
+}

package/src/daemon/server/handle-context-file-data.d.ts

@@ -0,0 +1,2 @@
+import { HandlerResult } from './server';
+export declare function handleContextFileData(): Promise<HandlerResult>;

package/src/daemon/server/handle-context-file-data.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleContextFileData = handleContextFileData;
+const workspace_context_1 = require("../../utils/workspace-context");
+const workspace_root_1 = require("../../utils/workspace-root");
+async function handleContextFileData() {
+    const files = await (0, workspace_context_1.getAllFileDataInContext)(workspace_root_1.workspaceRoot);
+    return {
+        response: JSON.stringify(files),
+        description: 'handleContextFileData',
+    };
+}

package/src/daemon/server/handle-flush-sync-generator-changes-to-disk.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerResult } from './server';
+export declare function handleFlushSyncGeneratorChangesToDisk(generators: string[]): Promise<HandlerResult>;

package/src/daemon/server/handle-flush-sync-generator-changes-to-disk.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleFlushSyncGeneratorChangesToDisk = handleFlushSyncGeneratorChangesToDisk;
+const sync_generators_1 = require("./sync-generators");
+async function handleFlushSyncGeneratorChangesToDisk(generators) {
+    const result = await (0, sync_generators_1.flushSyncGeneratorChangesToDisk)(generators);
+    return {
+        response: JSON.stringify(result),
+        description: 'handleFlushSyncGeneratorChangesToDisk',
+    };
+}

package/src/daemon/server/handle-force-shutdown.d.ts

@@ -0,0 +1,5 @@
+import { Server } from 'net';
+export declare function handleForceShutdown(server: Server): Promise<{
+    description: string;
+    response: string;
+}>;

package/src/daemon/server/handle-force-shutdown.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleForceShutdown = handleForceShutdown;
+const shutdown_utils_1 = require("./shutdown-utils");
+const server_1 = require("./server");
+async function handleForceShutdown(server) {
+    setTimeout(async () => {
+        await (0, shutdown_utils_1.handleServerProcessTermination)({
+            server,
+            reason: 'Request to shutdown',
+            sockets: server_1.openSockets,
+        });
+    });
+    return {
+        description: 'Shutdown initiated',
+        response: '{}',
+    };
+}

package/src/daemon/server/handle-get-files-in-directory.d.ts

@@ -0,0 +1,2 @@
+import { HandlerResult } from './server';
+export declare function handleGetFilesInDirectory(dir: string): Promise<HandlerResult>;

package/src/daemon/server/handle-get-files-in-directory.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetFilesInDirectory = handleGetFilesInDirectory;
+const workspace_context_1 = require("../../utils/workspace-context");
+const workspace_root_1 = require("../../utils/workspace-root");
+async function handleGetFilesInDirectory(dir) {
+    const files = await (0, workspace_context_1.getFilesInDirectoryUsingContext)(workspace_root_1.workspaceRoot, dir);
+    return {
+        response: JSON.stringify(files),
+        description: 'handleNxWorkspaceFiles',
+    };
+}

package/src/daemon/server/handle-get-registered-sync-generators.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerResult } from './server';
+export declare function handleGetRegisteredSyncGenerators(): Promise<HandlerResult>;

package/src/daemon/server/handle-get-registered-sync-generators.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetRegisteredSyncGenerators = handleGetRegisteredSyncGenerators;
+const sync_generators_1 = require("./sync-generators");
+async function handleGetRegisteredSyncGenerators() {
+    const syncGenerators = await (0, sync_generators_1.getCachedRegisteredSyncGenerators)();
+    return {
+        response: JSON.stringify(syncGenerators),
+        description: 'handleGetSyncGeneratorChanges',
+    };
+}

package/src/daemon/server/handle-get-sync-generator-changes.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerResult } from './server';
+export declare function handleGetSyncGeneratorChanges(generators: string[]): Promise<HandlerResult>;

package/src/daemon/server/handle-get-sync-generator-changes.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetSyncGeneratorChanges = handleGetSyncGeneratorChanges;
+const sync_generators_1 = require("./sync-generators");
+async function handleGetSyncGeneratorChanges(generators) {
+    const changes = await (0, sync_generators_1.getCachedSyncGeneratorChanges)(generators);
+    const result = changes.map((change) => 'error' in change
+        ? change
+        : // strip out the content of the changes and any potential callback
+            {
+                generatorName: change.generatorName,
+                changes: change.changes.map((c) => ({ ...c, content: null })),
+                outOfSyncMessage: change.outOfSyncMessage,
+            });
+    return {
+        response: JSON.stringify(result),
+        description: 'handleGetSyncGeneratorChanges',
+    };
+}

package/src/daemon/server/handle-glob.d.ts

@@ -0,0 +1,2 @@
+import { HandlerResult } from './server';
+export declare function handleGlob(globs: string[], exclude?: string[]): Promise<HandlerResult>;

package/src/daemon/server/handle-glob.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGlob = handleGlob;
+const workspace_root_1 = require("../../utils/workspace-root");
+const workspace_context_1 = require("../../utils/workspace-context");
+async function handleGlob(globs, exclude) {
+    const files = await (0, workspace_context_1.globWithWorkspaceContext)(workspace_root_1.workspaceRoot, globs, exclude);
+    return {
+        response: JSON.stringify(files),
+        description: 'handleGlob',
+    };
+}

package/src/daemon/server/handle-hash-glob.d.ts

@@ -0,0 +1,2 @@
+import { HandlerResult } from './server';
+export declare function handleHashGlob(globs: string[], exclude?: string[]): Promise<HandlerResult>;

package/src/daemon/server/handle-hash-glob.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHashGlob = handleHashGlob;
+const workspace_root_1 = require("../../utils/workspace-root");
+const workspace_context_1 = require("../../utils/workspace-context");
+async function handleHashGlob(globs, exclude) {
+    const files = await (0, workspace_context_1.hashWithWorkspaceContext)(workspace_root_1.workspaceRoot, globs, exclude);
+    return {
+        response: JSON.stringify(files),
+        description: 'handleHashGlob',
+    };
+}

package/src/daemon/server/handle-hash-tasks.d.ts

@@ -0,0 +1,10 @@
+import { Task, TaskGraph } from '../../config/task-graph';
+export declare function handleHashTasks(payload: {
+    runnerOptions: any;
+    env: any;
+    tasks: Task[];
+    taskGraph: TaskGraph;
+}): Promise<{
+    response: string;
+    description: string;
+}>;

package/src/daemon/server/handle-hash-tasks.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHashTasks = handleHashTasks;
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+const task_hasher_1 = require("../../hasher/task-hasher");
+const configuration_1 = require("../../config/configuration");
+const error_types_1 = require("../../project-graph/error-types");
+/**
+ * We use this not to recreated hasher for every hash operation
+ * TaskHasher has a cache inside, so keeping it around results in faster performance
+ */
+let storedProjectGraph = null;
+let storedHasher = null;
+async function handleHashTasks(payload) {
+    const { error, projectGraph: _graph, allWorkspaceFiles, fileMap, rustReferences, } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+    let projectGraph = _graph;
+    if (error) {
+        if (error instanceof error_types_1.DaemonProjectGraphError) {
+            projectGraph = error.projectGraph;
+        }
+        else {
+            throw error;
+        }
+    }
+    const nxJson = (0, configuration_1.readNxJson)();
+    if (projectGraph !== storedProjectGraph) {
+        storedProjectGraph = projectGraph;
+        storedHasher = new task_hasher_1.InProcessTaskHasher(fileMap?.projectFileMap, allWorkspaceFiles, projectGraph, nxJson, rustReferences, payload.runnerOptions);
+    }
+    const response = JSON.stringify(await storedHasher.hashTasks(payload.tasks, payload.taskGraph, payload.env));
+    return {
+        response,
+        description: 'handleHashTasks',
+    };
+}

package/src/daemon/server/handle-nx-workspace-files.d.ts

@@ -0,0 +1,2 @@
+import { HandlerResult } from './server';
+export declare function handleNxWorkspaceFiles(projectRootMap: Record<string, string>): Promise<HandlerResult>;

package/src/daemon/server/handle-nx-workspace-files.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleNxWorkspaceFiles = handleNxWorkspaceFiles;
+const workspace_context_1 = require("../../utils/workspace-context");
+const workspace_root_1 = require("../../utils/workspace-root");
+async function handleNxWorkspaceFiles(projectRootMap) {
+    const files = await (0, workspace_context_1.getNxWorkspaceFilesFromContext)(workspace_root_1.workspaceRoot, projectRootMap);
+    return {
+        response: JSON.stringify(files),
+        description: 'handleNxWorkspaceFiles',
+    };
+}

package/src/daemon/server/handle-outputs-tracking.d.ts

@@ -0,0 +1,15 @@
+import { HandlerResult } from './server';
+export declare function handleRecordOutputsHash(payload: {
+    type: string;
+    data: {
+        outputs: string[];
+        hash: string;
+    };
+}): Promise<HandlerResult>;
+export declare function handleOutputsHashesMatch(payload: {
+    type: string;
+    data: {
+        outputs: string[];
+        hash: string;
+    };
+}): Promise<HandlerResult>;

package/src/daemon/server/handle-outputs-tracking.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRecordOutputsHash = handleRecordOutputsHash;
+exports.handleOutputsHashesMatch = handleOutputsHashesMatch;
+const outputs_tracking_1 = require("./outputs-tracking");
+async function handleRecordOutputsHash(payload) {
+    try {
+        await (0, outputs_tracking_1.recordOutputsHash)(payload.data.outputs, payload.data.hash);
+        return {
+            description: 'recordOutputsHash',
+            response: '{}',
+        };
+    }
+    catch (e) {
+        return {
+            description: 'recordOutputsHash failed',
+            error: new Error(`Critical error when recording metadata about outputs: '${e.message}'.`),
+        };
+    }
+}
+async function handleOutputsHashesMatch(payload) {
+    try {
+        const res = await (0, outputs_tracking_1.outputsHashesMatch)(payload.data.outputs, payload.data.hash);
+        return {
+            response: JSON.stringify(res),
+            description: 'outputsHashesMatch',
+        };
+    }
+    catch (e) {
+        return {
+            description: 'outputsHashesMatch failed',
+            error: new Error(`Critical error when verifying the contents of the outputs haven't changed: '${e.message}'.`),
+        };
+    }
+}

package/src/daemon/server/handle-process-in-background.d.ts

@@ -0,0 +1,6 @@
+import { HandlerResult } from './server';
+export declare function handleProcessInBackground(payload: {
+    type: string;
+    requirePath: string;
+    data: any;
+}): Promise<HandlerResult>;

package/src/daemon/server/handle-process-in-background.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleProcessInBackground = handleProcessInBackground;
+const logger_1 = require("./logger");
+const installation_directory_1 = require("../../utils/installation-directory");
+async function handleProcessInBackground(payload) {
+    let fn;
+    try {
+        fn = require(require.resolve(payload.requirePath, {
+            paths: (0, installation_directory_1.getNxRequirePaths)(),
+        })).default;
+    }
+    catch (e) {
+        return {
+            description: `Unable to require ${payload.requirePath}`,
+            error: new Error(`Unable to require ${payload.requirePath}`),
+        };
+    }
+    try {
+        const response = await fn(payload.data, logger_1.serverLogger);
+        return {
+            response,
+            description: payload.type,
+        };
+    }
+    catch (e) {
+        return {
+            description: `Error when processing ${payload.type}.`,
+            error: e,
+        };
+    }
+}

package/src/daemon/server/handle-request-project-graph.d.ts

@@ -0,0 +1,2 @@
+import { HandlerResult } from './server';
+export declare function handleRequestProjectGraph(): Promise<HandlerResult>;