@ohos-ports/nx 17.3.2-beta.0

package/src/daemon/cache.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDaemonProcessIdSync = exports.safelyCleanUpExistingProcess = exports.writeDaemonJsonProcessCache = exports.deleteDaemonJsonProcessCache = exports.readDaemonProcessJsonCache = exports.serverProcessJsonPath = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const tmp_dir_1 = require("./tmp-dir");
+exports.serverProcessJsonPath = (0, path_1.join)(tmp_dir_1.DAEMON_DIR_FOR_CURRENT_WORKSPACE, 'server-process.json');
+async function readDaemonProcessJsonCache() {
+    if (!(0, fs_extra_1.existsSync)(exports.serverProcessJsonPath)) {
+        return null;
+    }
+    return await (0, fs_extra_1.readJson)(exports.serverProcessJsonPath);
+}
+exports.readDaemonProcessJsonCache = readDaemonProcessJsonCache;
+function deleteDaemonJsonProcessCache() {
+    try {
+        if (getDaemonProcessIdSync() === process.pid) {
+            (0, fs_extra_1.unlinkSync)(exports.serverProcessJsonPath);
+        }
+    }
+    catch { }
+}
+exports.deleteDaemonJsonProcessCache = deleteDaemonJsonProcessCache;
+async function writeDaemonJsonProcessCache(daemonJson) {
+    await (0, fs_extra_1.writeJson)(exports.serverProcessJsonPath, daemonJson);
+}
+exports.writeDaemonJsonProcessCache = writeDaemonJsonProcessCache;
+async function safelyCleanUpExistingProcess() {
+    const daemonProcessJson = await readDaemonProcessJsonCache();
+    if (daemonProcessJson && daemonProcessJson.processId) {
+        try {
+            process.kill(daemonProcessJson.processId);
+        }
+        catch { }
+    }
+    deleteDaemonJsonProcessCache();
+}
+exports.safelyCleanUpExistingProcess = safelyCleanUpExistingProcess;
+// Must be sync for the help output use case
+function getDaemonProcessIdSync() {
+    if (!(0, fs_extra_1.existsSync)(exports.serverProcessJsonPath)) {
+        return null;
+    }
+    try {
+        const daemonProcessJson = (0, fs_extra_1.readJsonSync)(exports.serverProcessJsonPath);
+        return daemonProcessJson.processId;
+    }
+    catch {
+        return null;
+    }
+}
+exports.getDaemonProcessIdSync = getDaemonProcessIdSync;

package/src/daemon/client/client.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChildProcess } from 'child_process';
+import { FileData, ProjectGraph } from '../../config/project-graph';
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { Hash } from '../../hasher/task-hasher';
+import { Task, TaskGraph } from '../../config/task-graph';
+import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration-utils';
+export type UnregisterCallback = () => void;
+export type ChangedFile = {
+    path: string;
+    type: 'create' | 'update' | 'delete';
+};
+export declare class DaemonClient {
+    private readonly nxJson;
+    constructor(nxJson: NxJsonConfiguration);
+    private queue;
+    private socketMessenger;
+    private currentMessage;
+    private currentResolve;
+    private currentReject;
+    private _enabled;
+    private _daemonStatus;
+    private _waitForDaemonReady;
+    private _daemonReady;
+    private _out;
+    private _err;
+    enabled(): boolean;
+    reset(): void;
+    requestShutdown(): Promise<void>;
+    getProjectGraphAndSourceMaps(): Promise<{
+        projectGraph: ProjectGraph;
+        sourceMaps: ConfigurationSourceMaps;
+    }>;
+    getAllFileData(): Promise<FileData[]>;
+    hashTasks(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<Hash[]>;
+    registerFileWatcher(config: {
+        watchProjects: string[] | 'all';
+        includeGlobalWorkspaceFiles?: boolean;
+        includeDependentProjects?: boolean;
+    }, callback: (error: Error | null | 'closed', data: {
+        changedProjects: string[];
+        changedFiles: ChangedFile[];
+    } | null) => void): Promise<UnregisterCallback>;
+    processInBackground(requirePath: string, data: any): Promise<any>;
+    recordOutputsHash(outputs: string[], hash: string): Promise<any>;
+    outputsHashesMatch(outputs: string[], hash: string): Promise<any>;
+    isServerAvailable(): Promise<boolean>;
+    private sendToDaemonViaQueue;
+    private setUpConnection;
+    private sendMessageToDaemon;
+    private handleMessage;
+    startInBackground(): Promise<ChildProcess['pid']>;
+    stop(): Promise<void>;
+}
+export declare const daemonClient: DaemonClient;

package/src/daemon/client/client.js

@@ -0,0 +1,359 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.daemonClient = exports.DaemonClient = void 0;
+const workspace_root_1 = require("../../utils/workspace-root");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const fs_extra_1 = require("fs-extra");
+const net_1 = require("net");
+const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
+const output_1 = require("../../utils/output");
+const socket_utils_1 = require("../socket-utils");
+const tmp_dir_1 = require("../tmp-dir");
+const is_ci_1 = require("../../utils/is-ci");
+const configuration_1 = require("../../config/configuration");
+const promised_based_queue_1 = require("../../utils/promised-based-queue");
+const nx_json_1 = require("../../config/nx-json");
+const daemon_socket_messenger_1 = require("./daemon-socket-messenger");
+const cache_1 = require("../cache");
+const DAEMON_ENV_SETTINGS = {
+    ...process.env,
+    NX_PROJECT_GLOB_CACHE: 'false',
+    NX_CACHE_PROJECTS_CONFIG: 'false',
+};
+var DaemonStatus;
+(function (DaemonStatus) {
+    DaemonStatus[DaemonStatus["CONNECTING"] = 0] = "CONNECTING";
+    DaemonStatus[DaemonStatus["DISCONNECTED"] = 1] = "DISCONNECTED";
+    DaemonStatus[DaemonStatus["CONNECTED"] = 2] = "CONNECTED";
+})(DaemonStatus || (DaemonStatus = {}));
+class DaemonClient {
+    constructor(nxJson) {
+        this.nxJson = nxJson;
+        this._daemonStatus = DaemonStatus.DISCONNECTED;
+        this._waitForDaemonReady = null;
+        this._daemonReady = null;
+        this._out = null;
+        this._err = null;
+        this.reset();
+    }
+    enabled() {
+        if (this._enabled === undefined) {
+            // TODO(v19): Add migration to move it out of existing configs and remove the ?? here.
+            const useDaemonProcessOption = this.nxJson.useDaemonProcess ??
+                this.nxJson.tasksRunnerOptions?.['default']?.options?.useDaemonProcess;
+            const env = process.env.NX_DAEMON;
+            // env takes precedence
+            // option=true,env=false => no daemon
+            // option=false,env=undefined => no daemon
+            // option=false,env=false => no daemon
+            // option=undefined,env=undefined => daemon
+            // option=true,env=true => daemon
+            // option=false,env=true => daemon
+            // CI=true,env=undefined => no daemon
+            // CI=true,env=false => no daemon
+            // CI=true,env=true => daemon
+            if (((0, is_ci_1.isCI)() && env !== 'true') ||
+                isDocker() ||
+                (0, tmp_dir_1.isDaemonDisabled)() ||
+                nxJsonIsNotPresent() ||
+                (useDaemonProcessOption === undefined && env === 'false') ||
+                (useDaemonProcessOption === true && env === 'false') ||
+                (useDaemonProcessOption === false && env === undefined) ||
+                (useDaemonProcessOption === false && env === 'false')) {
+                this._enabled = false;
+            }
+            else {
+                this._enabled = true;
+            }
+        }
+        return this._enabled;
+    }
+    reset() {
+        this.socketMessenger?.close();
+        this.socketMessenger = null;
+        this.queue = new promised_based_queue_1.PromisedBasedQueue();
+        this.currentMessage = null;
+        this.currentResolve = null;
+        this.currentReject = null;
+        this._enabled = undefined;
+        this._out?.close();
+        this._err?.close();
+        this._out = null;
+        this._err = null;
+        this._daemonStatus = DaemonStatus.DISCONNECTED;
+        this._waitForDaemonReady = new Promise((resolve) => (this._daemonReady = resolve));
+    }
+    async requestShutdown() {
+        return this.sendToDaemonViaQueue({ type: 'REQUEST_SHUTDOWN' });
+    }
+    async getProjectGraphAndSourceMaps() {
+        const response = await this.sendToDaemonViaQueue({
+            type: 'REQUEST_PROJECT_GRAPH',
+        });
+        return {
+            projectGraph: response.projectGraph,
+            sourceMaps: response.sourceMaps,
+        };
+    }
+    async getAllFileData() {
+        return await this.sendToDaemonViaQueue({ type: 'REQUEST_FILE_DATA' });
+    }
+    hashTasks(runnerOptions, tasks, taskGraph, env) {
+        return this.sendToDaemonViaQueue({
+            type: 'HASH_TASKS',
+            runnerOptions,
+            env,
+            tasks,
+            taskGraph,
+        });
+    }
+    async registerFileWatcher(config, callback) {
+        await this.getProjectGraphAndSourceMaps();
+        let messenger;
+        await this.queue.sendToQueue(() => {
+            messenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socket_utils_1.FULL_OS_SOCKET_PATH)).listen((message) => {
+                try {
+                    const parsedMessage = JSON.parse(message);
+                    callback(null, parsedMessage);
+                }
+                catch (e) {
+                    callback(e, null);
+                }
+            }, () => {
+                callback('closed', null);
+            }, (err) => callback(err, null));
+            return messenger.sendMessage({ type: 'REGISTER_FILE_WATCHER', config });
+        });
+        return () => {
+            messenger?.close();
+        };
+    }
+    processInBackground(requirePath, data) {
+        return this.sendToDaemonViaQueue({
+            type: 'PROCESS_IN_BACKGROUND',
+            requirePath,
+            data,
+        });
+    }
+    recordOutputsHash(outputs, hash) {
+        return this.sendToDaemonViaQueue({
+            type: 'RECORD_OUTPUTS_HASH',
+            data: {
+                outputs,
+                hash,
+            },
+        });
+    }
+    outputsHashesMatch(outputs, hash) {
+        return this.sendToDaemonViaQueue({
+            type: 'OUTPUTS_HASHES_MATCH',
+            data: {
+                outputs,
+                hash,
+            },
+        });
+    }
+    async isServerAvailable() {
+        return new Promise((resolve) => {
+            try {
+                const socket = (0, net_1.connect)(socket_utils_1.FULL_OS_SOCKET_PATH, () => {
+                    socket.destroy();
+                    resolve(true);
+                });
+                socket.once('error', () => {
+                    resolve(false);
+                });
+            }
+            catch (err) {
+                resolve(false);
+            }
+        });
+    }
+    async sendToDaemonViaQueue(messageToDaemon) {
+        return this.queue.sendToQueue(() => this.sendMessageToDaemon(messageToDaemon));
+    }
+    setUpConnection() {
+        this.socketMessenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socket_utils_1.FULL_OS_SOCKET_PATH)).listen((message) => this.handleMessage(message), () => {
+            // it's ok for the daemon to terminate if the client doesn't wait on
+            // any messages from the daemon
+            if (this.queue.isEmpty()) {
+                this.reset();
+            }
+            else {
+                output_1.output.error({
+                    title: 'Daemon process terminated and closed the connection',
+                    bodyLines: [
+                        'Please rerun the command, which will restart the daemon.',
+                        `If you get this error again, check for any errors in the daemon process logs found in: ${tmp_dir_1.DAEMON_OUTPUT_LOG_FILE}`,
+                    ],
+                });
+                this._daemonStatus = DaemonStatus.DISCONNECTED;
+                this.currentReject?.(daemonProcessException('Daemon process terminated and closed the connection'));
+                process.exit(1);
+            }
+        }, (err) => {
+            if (!err.message) {
+                return this.currentReject(daemonProcessException(err.toString()));
+            }
+            if (err.message.startsWith('LOCK-FILES-CHANGED')) {
+                // retry the current message
+                // we cannot send it via the queue because we are in the middle of processing
+                // a message from the queue
+                return this.sendMessageToDaemon(this.currentMessage).then(this.currentResolve, this.currentReject);
+            }
+            let error;
+            if (err.message.startsWith('connect ENOENT')) {
+                error = daemonProcessException('The Daemon Server is not running');
+            }
+            else if (err.message.startsWith('connect ECONNREFUSED')) {
+                error = daemonProcessException(`A server instance had not been fully shut down. Please try running the command again.`);
+                (0, socket_utils_1.killSocketOrPath)();
+            }
+            else if (err.message.startsWith('read ECONNRESET')) {
+                error = daemonProcessException(`Unable to connect to the daemon process.`);
+            }
+            else {
+                error = daemonProcessException(err.toString());
+            }
+            return this.currentReject(error);
+        });
+    }
+    async sendMessageToDaemon(message) {
+        if (this._daemonStatus == DaemonStatus.DISCONNECTED) {
+            this._daemonStatus = DaemonStatus.CONNECTING;
+            if (!(await this.isServerAvailable())) {
+                await this.startInBackground();
+            }
+            this.setUpConnection();
+            this._daemonStatus = DaemonStatus.CONNECTED;
+            this._daemonReady();
+        }
+        else if (this._daemonStatus == DaemonStatus.CONNECTING) {
+            await this._waitForDaemonReady;
+        }
+        return new Promise((resolve, reject) => {
+            perf_hooks_1.performance.mark('sendMessageToDaemon-start');
+            this.currentMessage = message;
+            this.currentResolve = resolve;
+            this.currentReject = reject;
+            this.socketMessenger.sendMessage(message);
+        });
+    }
+    handleMessage(serializedResult) {
+        try {
+            perf_hooks_1.performance.mark('json-parse-start');
+            const parsedResult = JSON.parse(serializedResult);
+            perf_hooks_1.performance.mark('json-parse-end');
+            perf_hooks_1.performance.measure('deserialize daemon response', 'json-parse-start', 'json-parse-end');
+            if (parsedResult.error) {
+                this.currentReject(parsedResult.error);
+            }
+            else {
+                perf_hooks_1.performance.measure('total for sendMessageToDaemon()', 'sendMessageToDaemon-start', 'json-parse-end');
+                return this.currentResolve(parsedResult);
+            }
+        }
+        catch (e) {
+            const endOfResponse = serializedResult.length > 300
+                ? serializedResult.substring(serializedResult.length - 300)
+                : serializedResult;
+            this.currentReject(daemonProcessException([
+                'Could not deserialize response from Nx daemon.',
+                `Message: ${e.message}`,
+                '\n',
+                `Received:`,
+                endOfResponse,
+                '\n',
+            ].join('\n')));
+        }
+    }
+    async startInBackground() {
+        (0, fs_extra_1.ensureDirSync)(tmp_dir_1.DAEMON_DIR_FOR_CURRENT_WORKSPACE);
+        (0, fs_extra_1.ensureFileSync)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE);
+        this._out = await (0, promises_1.open)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE, 'a');
+        this._err = await (0, promises_1.open)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE, 'a');
+        const backgroundProcess = (0, child_process_1.spawn)(process.execPath, [(0, path_1.join)(__dirname, '../server/start.js')], {
+            cwd: workspace_root_1.workspaceRoot,
+            stdio: ['ignore', this._out.fd, this._err.fd],
+            detached: true,
+            windowsHide: true,
+            shell: false,
+            env: DAEMON_ENV_SETTINGS,
+        });
+        backgroundProcess.unref();
+        /**
+         * Ensure the server is actually available to connect to via IPC before resolving
+         */
+        let attempts = 0;
+        return new Promise((resolve, reject) => {
+            const id = setInterval(async () => {
+                if (await this.isServerAvailable()) {
+                    clearInterval(id);
+                    resolve(backgroundProcess.pid);
+                }
+                else if (attempts > 6000) {
+                    // daemon fails to start, the process probably exited
+                    // we print the logs and exit the client
+                    reject(daemonProcessException('Failed to start or connect to the Nx Daemon process.'));
+                }
+                else {
+                    attempts++;
+                }
+            }, 10);
+        });
+    }
+    async stop() {
+        try {
+            await (0, cache_1.safelyCleanUpExistingProcess)();
+        }
+        catch (err) {
+            output_1.output.error({
+                title: err?.message ||
+                    'Something unexpected went wrong when stopping the server',
+            });
+        }
+        (0, tmp_dir_1.removeSocketDir)();
+    }
+}
+exports.DaemonClient = DaemonClient;
+exports.daemonClient = new DaemonClient((0, configuration_1.readNxJson)());
+function isDocker() {
+    try {
+        (0, fs_1.statSync)('/.dockerenv');
+        return true;
+    }
+    catch {
+        try {
+            return (0, fs_1.readFileSync)('/proc/self/cgroup', 'utf8')?.includes('docker');
+        }
+        catch { }
+        return false;
+    }
+}
+function nxJsonIsNotPresent() {
+    return !(0, nx_json_1.hasNxJson)(workspace_root_1.workspaceRoot);
+}
+function daemonProcessException(message) {
+    try {
+        let log = (0, fs_1.readFileSync)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE).toString().split('\n');
+        if (log.length > 20) {
+            log = log.slice(log.length - 20);
+        }
+        const error = new Error([
+            message,
+            '',
+            'Messages from the log:',
+            ...log,
+            '\n',
+            `More information: ${tmp_dir_1.DAEMON_OUTPUT_LOG_FILE}`,
+        ].join('\n'));
+        error.internalDaemonError = true;
+        return error;
+    }
+    catch (e) {
+        return new Error(message);
+    }
+}

package/src/daemon/client/daemon-socket-messenger.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Socket } from 'net';
+export interface Message extends Record<string, any> {
+    type: string;
+    data?: any;
+}
+export declare class DaemonSocketMessenger {
+    private socket;
+    constructor(socket: Socket);
+    sendMessage(messageToDaemon: Message): Promise<void>;
+    listen(onData: (message: string) => void, onClose?: () => void, onError?: (err: Error) => void): this;
+    close(): void;
+}

package/src/daemon/client/daemon-socket-messenger.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonSocketMessenger = void 0;
+const consume_messages_from_socket_1 = require("../../utils/consume-messages-from-socket");
+class DaemonSocketMessenger {
+    constructor(socket) {
+        this.socket = socket;
+    }
+    async sendMessage(messageToDaemon) {
+        this.socket.write(JSON.stringify(messageToDaemon));
+        // send EOT to indicate that the message has been fully written
+        this.socket.write(String.fromCodePoint(4));
+    }
+    listen(onData, onClose = () => { }, onError = (err) => { }) {
+        this.socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (message) => {
+            onData(message);
+        }));
+        this.socket.on('close', onClose);
+        this.socket.on('error', onError);
+        return this;
+    }
+    close() {
+        this.socket.destroy();
+    }
+}
+exports.DaemonSocketMessenger = DaemonSocketMessenger;

package/src/daemon/client/exec-is-server-available.d.ts

@@ -0,0 +1 @@
+export {};

package/src/daemon/client/exec-is-server-available.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("./client");
+(async () => {
+    try {
+        console.log(await client_1.daemonClient.isServerAvailable());
+    }
+    catch {
+        console.log(false);
+    }
+})();

package/src/daemon/client/generate-help-output.d.ts

@@ -0,0 +1 @@
+export declare function generateDaemonHelpOutput(): string;

package/src/daemon/client/generate-help-output.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDaemonHelpOutput = void 0;
+const child_process_1 = require("child_process");
+const cache_1 = require("../cache");
+const tmp_dir_1 = require("../tmp-dir");
+function generateDaemonHelpOutput() {
+    /**
+     * A workaround for cases such as yargs output where we need to synchronously
+     * get the value of this async operation.
+     */
+    const res = (0, child_process_1.spawnSync)(process.execPath, ['./exec-is-server-available.js'], {
+        cwd: __dirname,
+    });
+    const isServerAvailable = res?.stdout?.toString().trim().indexOf('true') > -1;
+    if (!isServerAvailable) {
+        return 'Nx Daemon is not running.';
+    }
+    const pid = (0, cache_1.getDaemonProcessIdSync)();
+    return `Nx Daemon is currently running:
+  - Logs: ${tmp_dir_1.DAEMON_OUTPUT_LOG_FILE}${pid
+        ? `
+  - Process ID: ${pid}`
+        : ''}`;
+}
+exports.generateDaemonHelpOutput = generateDaemonHelpOutput;

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

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

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