nx 23.2.1 → 23.3.0-beta.1

package/dist/src/utils/workspace-context.js

@@ -8,10 +8,19 @@ exports.multiGlobWithWorkspaceContext = multiGlobWithWorkspaceContext;
 exports.hashWithWorkspaceContext = hashWithWorkspaceContext;
 exports.hashMultiGlobWithWorkspaceContext = hashMultiGlobWithWorkspaceContext;
 exports.updateContextWithChangedFiles = updateContextWithChangedFiles;
+exports.trackedFilesInContext = trackedFilesInContext;
 exports.updateFilesInContext = updateFilesInContext;
 exports.getAllFileDataInContext = getAllFileDataInContext;
+exports.subscribeToWorkspaceChanges = subscribeToWorkspaceChanges;
+exports.settleWorkspaceContext = settleWorkspaceContext;
+exports.takeAppliedWorkspaceChanges = takeAppliedWorkspaceChanges;
+exports.isWatchingWorkspaceContext = isWatchingWorkspaceContext;
+exports.subscribeToWatchEvents = subscribeToWatchEvents;
+exports.isEmptyBatch = isEmptyBatch;
+exports.stopWatchingWorkspaceContext = stopWatchingWorkspaceContext;
 exports.getFilesInDirectoryUsingContext = getFilesInDirectoryUsingContext;
 exports.updateProjectFiles = updateProjectFiles;
+exports.refreshWorkspaceContext = refreshWorkspaceContext;
 exports.resetWorkspaceContext = resetWorkspaceContext;
 const perf_hooks_1 = require("perf_hooks");
 const cache_directory_1 = require("./cache-directory");
@@ -19,16 +28,36 @@ const is_on_daemon_1 = require("../daemon/is-on-daemon");
 const client_1 = require("../daemon/client/client");
 const handle_import_1 = require("./handle-import");
 let workspaceContext;
-function setupWorkspaceContext(workspaceRoot) {
+let filesReady;
+// Survive a reset: the daemon tears its context down and lets the next read
+// recreate it, and that context must watch and report like the one before.
+let contextOptions;
+let contextRoot;
+let contextGeneration = 0;
+const changeListeners = new Set();
+const eventListeners = new Set();
+function setupWorkspaceContext(workspaceRoot, options) {
     const { WorkspaceContext } = require('../native');
     perf_hooks_1.performance.mark('workspace-context');
-    workspaceContext = new WorkspaceContext(workspaceRoot, (0, cache_directory_1.workspaceDataDirectoryForWorkspace)(workspaceRoot));
+    const cacheDir = (0, cache_directory_1.workspaceDataDirectoryForWorkspace)(workspaceRoot);
+    // A plugin worker is only asked for files after its host finished walking
+    // and wrote the archive, so it loads that rather than walking again.
+    workspaceContext = global.NX_PLUGIN_WORKER
+        ? WorkspaceContext.fromArchive(workspaceRoot, cacheDir, options)
+        : new WorkspaceContext(workspaceRoot, cacheDir, options);
+    contextOptions = options;
+    contextRoot = workspaceRoot;
+    contextGeneration++;
+    filesReady = undefined;
+    if (options?.watch) {
+        attachSubscribers();
+    }
     perf_hooks_1.performance.mark('workspace-context:end');
     perf_hooks_1.performance.measure('workspace context init', 'workspace-context', 'workspace-context:end');
 }
 async function getNxWorkspaceFilesFromContext(workspaceRoot, projectRootMap, useDaemonProcess = true) {
     if (!useDaemonProcess || (0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.getWorkspaceFiles(projectRootMap);
     }
     return client_1.daemonClient.getWorkspaceFiles(projectRootMap);
@@ -46,7 +75,7 @@ function globWithWorkspaceContextSync(workspaceRoot, globs, exclude) {
 }
 async function globWithWorkspaceContext(workspaceRoot, globs, exclude) {
     if (workspaceRoot === '/virtual' || (0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.glob(globs, exclude);
     }
     else {
@@ -55,21 +84,21 @@ async function globWithWorkspaceContext(workspaceRoot, globs, exclude) {
 }
 async function multiGlobWithWorkspaceContext(workspaceRoot, globs, exclude) {
     if (workspaceRoot === '/virtual' || (0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.multiGlob(globs, exclude);
     }
     return client_1.daemonClient.multiGlob(globs, exclude);
 }
 async function hashWithWorkspaceContext(workspaceRoot, globs, exclude) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.hashFilesMatchingGlob(globs, exclude);
     }
     return client_1.daemonClient.hashGlob(globs, exclude);
 }
 async function hashMultiGlobWithWorkspaceContext(workspaceRoot, globGroups) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.hashFilesMatchingGlobs(globGroups);
     }
     return client_1.daemonClient.hashMultiGlob(globGroups);
@@ -89,20 +118,106 @@ async function updateContextWithChangedFiles(workspaceRoot, createdFiles, update
         await client_1.daemonClient.updateWorkspaceContext(createdFiles, updatedFiles, deletedFiles);
     }
 }
+/**
+ * The subset of `paths` the workspace file map holds: what the watch tracks,
+ * with the ignore rules applied.
+ */
+function trackedFilesInContext(workspaceRoot, paths) {
+    ensureContextAvailable(workspaceRoot);
+    return workspaceContext?.trackedFiles(paths) ?? [];
+}
 function updateFilesInContext(workspaceRoot, updatedFiles, deletedFiles) {
     ensureContextAvailable(workspaceRoot);
     return workspaceContext?.incrementalUpdate(updatedFiles, deletedFiles);
 }
 async function getAllFileDataInContext(workspaceRoot) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.allFileData();
     }
     return client_1.daemonClient.getWorkspaceContextFileData();
 }
+/**
+ * Listens for the changes a watching context applies: each change reaches the
+ * listeners once, here or in `settleWorkspaceContext`, whichever takes it
+ * first. Any number of listeners may listen. Returns a function that stops
+ * this one.
+ */
+function subscribeToWorkspaceChanges(workspaceRoot, listener) {
+    changeListeners.add(listener);
+    ensureContextAvailable(workspaceRoot);
+    attachSubscribers();
+    return () => changeListeners.delete(listener);
+}
+/**
+ * Applies every change the watcher has delivered, waiting out the kernel hop,
+ * and takes every change applied and not yet handed out. Empty when the
+ * context is not watching.
+ */
+function settleWorkspaceContext(workspaceRoot) {
+    ensureContextAvailable(workspaceRoot);
+    return workspaceContext.settle();
+}
+/**
+ * Takes every change applied and not yet handed out, without waiting for the
+ * watcher: for a caller that has just applied changes itself.
+ */
+function takeAppliedWorkspaceChanges(workspaceRoot) {
+    ensureContextAvailable(workspaceRoot);
+    return workspaceContext.takeAppliedChanges();
+}
+function isWatchingWorkspaceContext() {
+    return !!contextOptions?.watch;
+}
+/**
+ * Listens for every event the context's watch delivers, including writes
+ * under ignored directories and the `rescan` marker. Any number of listeners
+ * may listen. Returns a function that stops this one.
+ */
+function subscribeToWatchEvents(workspaceRoot, listener) {
+    eventListeners.add(listener);
+    ensureContextAvailable(workspaceRoot);
+    attachSubscribers();
+    return () => eventListeners.delete(listener);
+}
+/** Whether a batch carries no change at all. */
+function isEmptyBatch(batch) {
+    return (batch.createdFiles.length === 0 &&
+        batch.updatedFiles.length === 0 &&
+        batch.deletedFiles.length === 0);
+}
+/**
+ * The native context takes one subscriber per stream; it fans out here. A
+ * delivery a replaced context had already queued does not reach listeners as
+ * if it came from the current one.
+ */
+function attachSubscribers() {
+    if (!workspaceContext || !contextOptions?.watch)
+        return;
+    const generation = contextGeneration;
+    const current = () => generation === contextGeneration;
+    workspaceContext.onChanges((err, batch) => {
+        if (!current() || (!err && (!batch || isEmptyBatch(batch))))
+            return;
+        for (const listener of changeListeners)
+            listener(err, batch);
+    });
+    workspaceContext.onWatchEvents((err, events) => {
+        if (!current())
+            return;
+        for (const listener of eventListeners)
+            listener(err, events);
+    });
+}
+function stopWatchingWorkspaceContext() {
+    changeListeners.clear();
+    eventListeners.clear();
+    contextOptions = undefined;
+    workspaceContext?.stopWatching();
+}
 async function getFilesInDirectoryUsingContext(workspaceRoot, dir) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.getFilesInDirectory(dir);
     }
     return client_1.daemonClient.getFilesInDirectory(dir);
@@ -110,11 +225,48 @@ async function getFilesInDirectoryUsingContext(workspaceRoot, dir) {
 function updateProjectFiles(projectRootMappings, rustReferences, updatedFiles, deletedFiles) {
     return workspaceContext?.updateProjectFiles(projectRootMappings, rustReferences.projectFiles, rustReferences.globalFiles, updatedFiles, deletedFiles);
 }
+/**
+ * Waits for the walk behind the context without holding the event loop. The
+ * native readers block the calling thread until the files exist, so the async
+ * entry points await this first; a plugin host is then never frozen while a
+ * worker is connecting to it.
+ */
+async function ensureFilesReady(workspaceRoot) {
+    ensureContextAvailable(workspaceRoot);
+    // A binding without `ready` (an older native build, a mocked one) reads
+    // synchronously as before.
+    filesReady ??= workspaceContext.ready?.() ?? Promise.resolve();
+    await filesReady;
+}
+/**
+ * Re-walks the host's files so the archive its plugin workers load includes
+ * writes made since the last walk, such as a migration flushing to disk. The
+ * walk is selective and shared through the files lock; one still running is
+ * reused rather than repeated.
+ */
+function refreshWorkspaceContext(workspaceRoot) {
+    if (workspaceRoot === '/virtual' || (0, is_on_daemon_1.isOnDaemon)() || client_1.daemonClient.enabled()) {
+        return;
+    }
+    if (workspaceContext?.workspaceRoot !== workspaceRoot) {
+        setupWorkspaceContext(workspaceRoot);
+        return;
+    }
+    workspaceContext.refresh();
+    filesReady = undefined;
+}
 function ensureContextAvailable(workspaceRoot) {
     if (!workspaceContext || workspaceContext?.workspaceRoot !== workspaceRoot) {
-        setupWorkspaceContext(workspaceRoot);
+        setupWorkspaceContext(workspaceRoot, contextOptions);
     }
 }
 function resetWorkspaceContext() {
+    workspaceContext?.stopWatching?.();
     workspaceContext = undefined;
+    filesReady = undefined;
+    // A watching context is the daemon's only watch; left for the next read to
+    // re-create, output and dotenv events in between would be lost.
+    if (contextOptions?.watch && contextRoot) {
+        setupWorkspaceContext(contextRoot, contextOptions);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "23.2.1",
+  "version": "23.3.0-beta.1",
   "private": false,
   "type": "commonjs",
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
@@ -152,7 +152,7 @@
     "semver": "7.8.4",
     "signal-exit": "3.0.7",
     "sisteransi": "1.0.5",
-    "smol-toml": "1.6.1",
+    "smol-toml": "1.7.1",
     "string-width": "4.2.3",
     "string_decoder": "1.3.0",
     "strip-ansi": "6.0.1",
@@ -185,16 +185,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "23.2.1",
-    "@nx/nx-darwin-x64": "23.2.1",
-    "@nx/nx-freebsd-x64": "23.2.1",
-    "@nx/nx-linux-arm-gnueabihf": "23.2.1",
-    "@nx/nx-linux-arm64-gnu": "23.2.1",
-    "@nx/nx-linux-arm64-musl": "23.2.1",
-    "@nx/nx-linux-x64-gnu": "23.2.1",
-    "@nx/nx-linux-x64-musl": "23.2.1",
-    "@nx/nx-win32-arm64-msvc": "23.2.1",
-    "@nx/nx-win32-x64-msvc": "23.2.1"
+    "@nx/nx-darwin-arm64": "23.3.0-beta.1",
+    "@nx/nx-darwin-x64": "23.3.0-beta.1",
+    "@nx/nx-freebsd-x64": "23.3.0-beta.1",
+    "@nx/nx-linux-arm-gnueabihf": "23.3.0-beta.1",
+    "@nx/nx-linux-arm64-gnu": "23.3.0-beta.1",
+    "@nx/nx-linux-arm64-musl": "23.3.0-beta.1",
+    "@nx/nx-linux-x64-gnu": "23.3.0-beta.1",
+    "@nx/nx-linux-x64-musl": "23.3.0-beta.1",
+    "@nx/nx-win32-arm64-msvc": "23.3.0-beta.1",
+    "@nx/nx-win32-x64-msvc": "23.3.0-beta.1"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/schemas/nx-schema.json

@@ -664,6 +664,10 @@
               "dependencies": {
                 "type": "boolean",
                 "description": "Include files matching the fileset for all the project dependencies of this target."
+              },
+              "includeIgnored": {
+                "type": "boolean",
+                "description": "Hash the glob straight from disk instead of the workspace file map, so gitignored or generated files can be inputs. A missing exact path still takes part in the hash. A ! negation only filters includeIgnored matches when it also sets includeIgnored: true."
               }
             },
             "required": ["fileset"],

package/schemas/project-schema.json

@@ -220,6 +220,10 @@
               "dependencies": {
                 "type": "boolean",
                 "description": "Include files matching the fileset for all the project dependencies of this target."
+              },
+              "includeIgnored": {
+                "type": "boolean",
+                "description": "Hash the glob straight from disk instead of the workspace file map, so gitignored or generated files can be inputs. A missing exact path still takes part in the hash. A ! negation only filters includeIgnored matches when it also sets includeIgnored: true."
               }
             },
             "required": ["fileset"],

package/dist/src/daemon/server/file-watching/route-workspace-changes.d.ts

@@ -1,9 +0,0 @@
-import type { WatchEvent } from '../../../native';
-/**
- * Categorise a batch of watcher events by type and route them into the
- * recomputation queue. Deletions are taken at face value; created and
- * updated paths are stat'd to skip directories (the project graph only
- * cares about files). A stat error means the file was unlinked between
- * the watcher firing and us looking — drop the event.
- */
-export declare function routeWorkspaceChanges(events: WatchEvent[]): void;

package/dist/src/daemon/server/file-watching/route-workspace-changes.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.routeWorkspaceChanges = routeWorkspaceChanges;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const workspace_root_1 = require("../../../utils/workspace-root");
-const logger_1 = require("../../logger");
-const project_graph_incremental_recomputation_1 = require("../project-graph-incremental-recomputation");
-const SUMMARY_CAP = 10;
-function summarize(files) {
-    if (files.length === 0)
-        return '(none)';
-    if (files.length <= SUMMARY_CAP) {
-        return files.map((f) => `  - ${f}`).join('\n');
-    }
-    return (files
-        .slice(0, SUMMARY_CAP)
-        .map((f) => `  - ${f}`)
-        .join('\n') + `\n  ... and ${files.length - SUMMARY_CAP} more`);
-}
-/**
- * Categorise a batch of watcher events by type and route them into the
- * recomputation queue. Deletions are taken at face value; created and
- * updated paths are stat'd to skip directories (the project graph only
- * cares about files). A stat error means the file was unlinked between
- * the watcher firing and us looking — drop the event.
- */
-function routeWorkspaceChanges(events) {
-    logger_1.serverLogger.watcherLog(`[watcher] routeWorkspaceChanges batch: ${events.length} events: ` +
-        events.map((e) => `${e.type}:${e.path}`).join(', '));
-    const updatedFilesToHash = [];
-    const createdFilesToHash = [];
-    const deletedFiles = [];
-    const droppedDirs = [];
-    const droppedStatErrors = [];
-    for (const event of events) {
-        if (event.type === 'delete') {
-            deletedFiles.push(event.path);
-            continue;
-        }
-        try {
-            const s = (0, node_fs_1.statSync)((0, node_path_1.join)(workspace_root_1.workspaceRoot, event.path));
-            if (!s.isFile()) {
-                droppedDirs.push(event.path);
-                continue;
-            }
-            if (event.type === 'update') {
-                updatedFilesToHash.push(event.path);
-            }
-            else {
-                createdFilesToHash.push(event.path);
-            }
-        }
-        catch (e) {
-            droppedStatErrors.push(`${event.path} (${e instanceof Error ? e.message : String(e)})`);
-            // File deleted between watcher emit and stat — drop it.
-        }
-    }
-    if (createdFilesToHash.length ||
-        updatedFilesToHash.length ||
-        deletedFiles.length ||
-        droppedDirs.length ||
-        droppedStatErrors.length) {
-        logger_1.serverLogger.watcherLog(`File changes detected:\n` +
-            `Created:\n${summarize(createdFilesToHash)}\n` +
-            `Updated:\n${summarize(updatedFilesToHash)}\n` +
-            `Deleted:\n${summarize(deletedFiles)}` +
-            (droppedDirs.length
-                ? `\nDropped (dirs):\n${summarize(droppedDirs)}`
-                : '') +
-            (droppedStatErrors.length
-                ? `\nDropped (stat errors):\n${summarize(droppedStatErrors)}`
-                : ''));
-    }
-    (0, project_graph_incremental_recomputation_1.scheduleProjectGraphRecomputation)(createdFilesToHash, updatedFilesToHash, deletedFiles);
-}

package/dist/src/daemon/server/watcher.d.ts

@@ -1,18 +0,0 @@
-import { Server } from 'net';
-import type { WatchEvent } from '../../native';
-export type FileWatcherCallback = (err: Error | string | null, changeEvents: WatchEvent[] | null) => Promise<void>;
-export declare function watchWorkspace(server: Server, cb: FileWatcherCallback): Promise<any>;
-/**
- * Synchronously drain anything the workspace watcher has buffered and feed
- * it through the normal change-handling pipeline. Call this before serving
- * a cached project graph so we never return data that the watcher has
- * already seen invalidated but hasn't flushed yet.
- */
-export declare function flushPendingWorkspaceChanges(): Promise<void>;
-export declare function watchOutputFiles(server: Server, cb: FileWatcherCallback): Promise<any>;
-/**
- * NOTE: An event type of "create" will also apply to the case where the user has restored
- * an original version of a file after modifying/deleting it by using git, so we adjust
- * our log language accordingly.
- */
-export declare function convertChangeEventsToLogMessage(changeEvents: WatchEvent[]): string;

package/dist/src/daemon/server/watcher.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.watchWorkspace = watchWorkspace;
-exports.flushPendingWorkspaceChanges = flushPendingWorkspaceChanges;
-exports.watchOutputFiles = watchOutputFiles;
-exports.convertChangeEventsToLogMessage = convertChangeEventsToLogMessage;
-const workspace_root_1 = require("../../utils/workspace-root");
-const path_1 = require("path");
-const shutdown_utils_1 = require("./shutdown-utils");
-const path_2 = require("../../utils/path");
-const cache_1 = require("../cache");
-const server_1 = require("./server");
-const handle_import_1 = require("../../utils/handle-import");
-// Captured by watchWorkspace so flushPendingWorkspaceChanges can route
-// force-flushed events through the same handling as the async callback.
-// Definite-assignment: dispatchWorkspaceChanges only runs after
-// watchWorkspace has set both, so reading them as non-nullable is safe.
-let activeServer;
-let workspaceChangesCallback;
-function dispatchWorkspaceChanges(events) {
-    for (const event of events) {
-        if (event.path.endsWith('.gitignore') || event.path === '.nxignore') {
-            // If the ignore files themselves have changed we need to dynamically
-            // update our cached ignoreGlobs
-            (0, shutdown_utils_1.handleServerProcessTermination)({
-                server: activeServer,
-                reason: 'Stopping the daemon the set of ignored files changed (native)',
-                sockets: server_1.openSockets,
-            });
-        }
-    }
-    return workspaceChangesCallback(null, events);
-}
-async function watchWorkspace(server, cb) {
-    const { Watcher } = await (0, handle_import_1.handleImport)('../../native/index.js', __dirname);
-    activeServer = server;
-    workspaceChangesCallback = cb;
-    const watcher = new Watcher(workspace_root_1.workspaceRoot);
-    watcher.watch((err, events) => {
-        if (err) {
-            return cb(err, null);
-        }
-        dispatchWorkspaceChanges(events);
-    });
-    return watcher;
-}
-/**
- * Synchronously drain anything the workspace watcher has buffered and feed
- * it through the normal change-handling pipeline. Call this before serving
- * a cached project graph so we never return data that the watcher has
- * already seen invalidated but hasn't flushed yet.
- */
-async function flushPendingWorkspaceChanges() {
-    const watcher = (0, shutdown_utils_1.getWatcherInstance)();
-    if (!watcher)
-        return;
-    const events = watcher.forceFlushPending();
-    if (events.length === 0)
-        return;
-    await dispatchWorkspaceChanges(events);
-}
-async function watchOutputFiles(server, cb) {
-    const { Watcher } = await (0, handle_import_1.handleImport)('../../native/index.js', __dirname);
-    const relativeServerProcess = (0, path_2.normalizePath)((0, path_1.relative)(workspace_root_1.workspaceRoot, cache_1.serverProcessJsonPath));
-    const watcher = new Watcher(workspace_root_1.workspaceRoot, [`!${relativeServerProcess}`], false);
-    watcher.watch((err, events) => {
-        if (err) {
-            return cb(err, null);
-        }
-        for (const event of events) {
-            if (event.path == relativeServerProcess &&
-                (0, cache_1.getDaemonProcessIdSync)() !== process.pid) {
-                return (0, shutdown_utils_1.handleServerProcessTermination)({
-                    server,
-                    reason: 'this process is no longer the current daemon (native)',
-                    sockets: server_1.openSockets,
-                });
-            }
-        }
-        if (events.length !== 0) {
-            cb(null, events);
-        }
-    });
-    return watcher;
-}
-/**
- * NOTE: An event type of "create" will also apply to the case where the user has restored
- * an original version of a file after modifying/deleting it by using git, so we adjust
- * our log language accordingly.
- */
-function convertChangeEventsToLogMessage(changeEvents) {
-    // If only a single file was changed, show the information inline
-    if (changeEvents.length === 1) {
-        const { path, type } = changeEvents[0];
-        let typeLog = 'updated';
-        switch (type) {
-            case 'create':
-                typeLog = 'created or restored';
-                break;
-            case 'update':
-                typeLog = 'modified';
-                break;
-            case 'delete':
-                typeLog = 'deleted';
-                break;
-        }
-        return `${path} was ${typeLog}`;
-    }
-    let numCreatedOrRestoredFiles = 0;
-    let numModifiedFiles = 0;
-    let numDeletedFiles = 0;
-    for (const event of changeEvents) {
-        switch (event.type) {
-            case 'create':
-                numCreatedOrRestoredFiles++;
-                break;
-            case 'update':
-                numModifiedFiles++;
-                break;
-            case 'delete':
-                numDeletedFiles++;
-                break;
-        }
-    }
-    return `${numCreatedOrRestoredFiles} file(s) created or restored, ${numModifiedFiles} file(s) modified, ${numDeletedFiles} file(s) deleted`;
-}