11.2.0

changelog.md

@@ -0,0 +1,357 @@
+# Changelog
+
+## 2025-01-29 - 11.2.0 - feat(fs)
+Enhanced copy method with optional replaceTargetDir option for directory replacement
+
+- Added optional 'replaceTargetDir' option to 'copy' and 'copySync' methods in 'fs.ts'.
+- The 'replaceTargetDir' option allows replacing the target directory if both source and target are directories.
+
+## 2025-01-29 - 11.1.9 - fix(fs)
+Fix directory handling in copy and copySync functions
+
+- Ensured existing directories at destination are removed before copying over them in async copy.
+- Added a similar check and handling for synchronous copySync when destination is a directory.
+
+## 2025-01-29 - 11.1.8 - fix(fs)
+Fixed copy and copySync functions to ensure they always overwrite files.
+
+- Fixed bug in copy function where files were not being overwritten when they already existed at the destination.
+- Fixed bug in copySync function to ensure files are overwritten to match the async function's behavior.
+
+## 2025-01-29 - 11.1.7 - fix(fs)
+Refactor copy and copySync functions to simplify return type
+
+- Changed the return type of fs.copy and fs.copySync from boolean to void.
+- Removed unnecessary promise handling in fs.copy.
+
+## 2025-01-29 - 11.1.6 - fix(fs)
+Fix issues with fs file copy functions.
+
+- Updated dependencies in package.json.
+- Corrected comments for asynchronous and synchronous file copy functions in fs.ts.
+
+## 2025-01-07 - 11.1.5 - fix(fs)
+Improve waitForFileToBeReady function to handle directories and file stabilization
+
+- Enhanced the waitForFileToBeReady to handle directory paths by checking for file existence within directories and waiting for stabilization.
+- Modified the watcher logic to cater to changes when monitoring directories for file appearance.
+- Introduced a helper function to ensure paths exist and another to resolve the first file in directories.
+- Corrected logic for polling and stabilizing files within directories.
+
+## 2025-01-07 - 11.1.4 - fix(fs)
+Fix file existence check in waitForFileToBeReady method.
+
+- Ensured that the directory and file exist before setting up the watcher in waitForFileToBeReady.
+- Changed ensureDirectoryExists to ensureFileExists for correct file path verification.
+- Handled ENOENT errors correctly to retry file existence checks until timeout is reached.
+
+## 2025-01-07 - 11.1.3 - fix(fs)
+Fix TypeScript type issue in fs module
+
+- Corrected a TypeScript type in the fs module's checkFileStability function.
+
+## 2025-01-07 - 11.1.2 - fix(fs)
+Fix issues in file stability check and directory existence verification in fs module
+
+- Removed unused variable 'isFileAvailable' in 'waitForFileToBeReady'.
+- Fixed logic for ensuring the target directory exists before setting up file stability watcher.
+- Refactored directory existence logic into 'ensureDirectoryExists' function.
+
+## 2025-01-07 - 11.1.1 - fix(fs)
+Improve waitForFileToBeReady function for file stability detection
+
+- Enhanced error handling and file stability checks in waitForFileToBeReady function
+- Added timeout feature for file readiness check
+- Improved directory access check before file availability check
+
+## 2025-01-07 - 11.1.0 - feat(SmartFile)
+Add rename functionality to SmartFile class
+
+- Implemented a new method to rename a file within the SmartFile class.
+- The rename method updates the file path and optionally writes the renamed file to the disk.
+
+## 2024-12-15 - 11.0.23 - fix(fs)
+Handle errors in toObjectSync method
+
+- Added error handling in toObjectSync function to capture and provide more informative error messages.
+
+## 2024-06-23 - 11.0.22 - fix(core)
+Update dependencies and changelog
+
+- Updated @push.rocks/smartstream to ^3.0.44
+- Updated glob to ^10.4.2
+- Updated @types/node to ^20.14.8
+
+## 2024-06-23 - 11.0.21 - fix(dependencies)
+Update dependencies to latest versions
+
+- Updated @push.rocks/smartpromise to ^4.0.4
+- Updated @push.rocks/smartstream to ^3.0.44
+- Updated glob to ^10.4.2
+- Updated @types/node to ^20.14.8
+
+## 2024-06-07 - 11.0.20 - Changelog
+11.0.20
+
+## 2024-06-07 - 11.0.19 - fix(core): update
+11.0.19
+
+- fix(core): update
+
+## 2024-06-07 - 11.0.18 - fix(core): update
+11.0.18
+
+- fix(core): update
+
+## 2024-06-06 - 11.0.17 - fix(core): update
+11.0.17
+
+- fix(core): update
+
+## 2024-06-06 - 11.0.16 - fix(core): update
+11.0.16
+
+- fix(core): update
+
+## 2024-05-29 - 11.0.16 - update description
+11.0.16
+
+- update description
+
+## 2024-05-17 - 11.0.15 - fix(core): update
+11.0.15
+
+- fix(core): update
+
+## 2024-04-14 - 11.0.14 - update tsconfig
+11.0.14
+
+- update tsconfig
+
+## 2024-04-12 - 11.0.13 - fix(core): update
+11.0.13
+
+- fix(core): update
+
+## 2024-04-12 - 11.0.12 - fix(core): update
+11.0.12
+
+- fix(core): update
+
+## 2024-04-12 - 11.0.11 - fix(core): update
+11.0.11
+
+- fix(core): update
+
+## 2024-04-03 - 11.0.10 - fix(core): update
+11.0.10
+
+- fix(core): update
+
+## 2024-04-03 - 11.0.9 - fix(core): update
+11.0.9
+
+- fix(core): update
+
+## 2024-04-02 - 11.0.8 - fix(core): update
+11.0.8
+
+- fix(core): update
+
+## 2024-04-02 - 11.0.7 - fix(core): update
+11.0.7
+
+- fix(core): update
+
+## 2024-04-02 - 11.0.6 - fix(core): update
+11.0.6
+
+- fix(core): update
+
+## 2024-04-01 - 11.0.5 - update npmextra.json
+11.0.5
+
+- update npmextra.json: githost
+
+## 2024-04-01 - 11.0.4 - fix(core): update
+11.0.4
+
+- fix(core): update
+
+## 2023-11-24 - 11.0.3 - fix(core): update
+11.0.3
+
+- fix(core): update
+
+## 2023-11-07 - 11.0.2 - fix(core): update
+11.0.2
+
+- fix(core): update
+
+## 2023-11-07 - 11.0.1 - fix(core): update
+11.0.1
+
+- fix(core): update
+
+## 2023-11-06 - 11.0.0 - fix(core): update
+11.0.0
+
+- fix(core): update
+
+## 2023-11-06 - 10.0.40 - BREAKING CHANGE(core): update
+10.0.40
+
+- BREAKING CHANGE(core): update
+
+## 2023-11-04 - 10.0.39 - fix(core): update
+10.0.39
+
+- fix(core): update
+
+## 2023-11-04 - 10.0.38 - fix(core): update
+10.0.38
+
+- fix(core): update
+
+## 2023-11-04 - 10.0.37 - fix(core): update
+10.0.37
+
+- fix(core): update
+
+## 2023-11-03 - 10.0.36 - fix(core): update
+10.0.36
+
+- fix(core): update
+
+## 2023-11-03 - 10.0.35 - fix(core): update
+10.0.35
+
+- fix(core): update
+
+## 2023-11-03 - 10.0.34 - fix(core): update
+10.0.34
+
+- fix(core): update
+
+## 2023-11-03 - 10.0.33 - fix(core): update
+10.0.33
+
+- fix(core): update
+
+## 2023-10-12 - 10.0.32 - fix(core): update
+10.0.32
+
+- fix(core): update
+
+## 2023-09-22 - 10.0.31 - fix(core): update
+10.0.31
+
+- fix(core): update
+
+## 2023-08-31 - 10.0.30 - fix(core): update
+10.0.30
+
+- fix(core): update
+
+## 2023-08-23 - 10.0.29 - fix(core): update
+10.0.29
+
+- fix(core): update
+
+## 2023-07-12 - 10.0.28 - fix(core): update
+10.0.28
+
+- fix(core): update
+
+## 2023-07-10 - 10.0.27 - fix(core): update
+10.0.27
+
+- fix(core): update
+
+## 2023-07-10 - 10.0.26 - fix(core): update
+10.0.26
+
+- fix(core): update
+
+## 2023-07-08 - 10.0.25 - fix(core): update
+10.0.25
+
+- fix(core): update
+
+## 2023-06-25 - 10.0.24 to 10.0.14 - Series of Fixes
+10.0.24 to 10.0.14
+
+- Series of fixes in the core module
+
+## 2023-01-09 - 10.0.13 to 10.0.6 - Series of Fixes
+10.0.13 to 10.0.6
+
+- Series of fixes in the core module
+
+## 2022-09-05 - 10.0.5 to 10.0.3 - Series of Fixes
+10.0.5 to 10.0.3
+
+- Series of fixes in the core module
+
+## 2022-06-07 - 10.0.2 to 10.0.1 - Series of Fixes
+10.0.2 to 10.0.1
+
+- Series of fixes in the core module
+
+## 2022-06-07 - 9.0.7 - BREAKING CHANGE(core): switch to esm
+9.0.7
+
+- BREAKING CHANGE(core): switch to esm
+
+## 2022-03-11 - 9.0.6 to 9.0.2 - Series of Fixes
+9.0.6 to 9.0.2
+
+- Series of fixes in the core module
+
+## 2021-12-01 - 9.0.1 - fix(core): update
+9.0.1
+
+- fix(core): update
+
+## 2021-12-01 - 9.0.0 - fix(absolute pathing)
+9.0.0
+
+- add functions for easily getting absolute paths
+
+## 2021-11-30 - 8.0.11 - BREAKING CHANGE(relative pathing)
+8.0.11
+
+- improved relative pathing
+
+## 2020-08-10 - 8.0.10 to 7.0.12 - Series of Fixes and Updates
+8.0.10 to 7.0.12
+
+- Series of fixes in the core module
+- BREAKING CHANGE(Smartfile class): switch to a Buffer-only approach
+
+## 2019-02-17 - 7.0.0 - fix(core): update dependencies
+7.0.0
+
+- fix(core): update dependencies
+
+## 2019-01-27 - 6.0.12 - BREAKING CHANGE(smartfile.fs.fileExists)
+6.0.12
+
+- now returns a Promise<boolean>
+
+## 2018-08-19 - 6.0.11 to 6.0.6 - Series of Fixes
+6.0.11 to 6.0.6
+
+- Series of fixes in core and dependencies
+
+## 2018-07-03 - 6.0.5 to 5.0.0 - Series of Fixes
+6.0.5 to 5.0.0
+
+- Series of fixes in core and dependencies
+
+## 2018-02-16 - 4.2.28 - BREAKING CHANGE(scope)
+4.2.28
+
+- switch to pushrocks scope
+
+

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@push.rocks/smartfile",
   "private": false,
-  "version": "11.0.20",
+  "version": "11.2.0",
   "description": "Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
@@ -42,29 +42,29 @@
   },
   "homepage": "https://code.foss.global/push.rocks/smartfile",
   "dependencies": {
-    "@push.rocks/lik": "^6.0.15",
+    "@push.rocks/lik": "^6.1.0",
     "@push.rocks/smartdelay": "^3.0.5",
     "@push.rocks/smartfile-interfaces": "^1.0.7",
     "@push.rocks/smarthash": "^3.0.4",
     "@push.rocks/smartjson": "^5.0.20",
-    "@push.rocks/smartmime": "^2.0.2",
+    "@push.rocks/smartmime": "^2.0.4",
     "@push.rocks/smartpath": "^5.0.18",
-    "@push.rocks/smartpromise": "^4.0.2",
+    "@push.rocks/smartpromise": "^4.2.2",
-    "@push.rocks/smartrequest": "^2.0.22",
+    "@push.rocks/smartrequest": "^2.0.23",
-    "@push.rocks/smartstream": "^3.0.38",
+    "@push.rocks/smartstream": "^3.2.5",
     "@types/fs-extra": "^11.0.4",
     "@types/glob": "^8.1.0",
     "@types/js-yaml": "^4.0.9",
-    "fs-extra": "^11.2.0",
+    "fs-extra": "^11.3.0",
-    "glob": "^10.4.1",
+    "glob": "^11.0.1",
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.80",
+    "@git.zone/tsbuild": "^2.2.1",
-    "@git.zone/tsrun": "^1.2.46",
+    "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^1.0.90",
+    "@git.zone/tstest": "^1.0.96",
-    "@push.rocks/tapbundle": "^5.0.23",
+    "@push.rocks/tapbundle": "^5.5.6",
-    "@types/node": "^20.12.12"
+    "@types/node": "^22.12.0"
   },
   "files": [
     "ts/**/*",

ts/00_commitinfo_data.ts

@@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
   name: '@push.rocks/smartfile',
-  version: '11.0.20',
+  version: '11.2.0',
   description: 'Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.'
 }

ts/classes.smartfile.ts

@@ -91,7 +91,7 @@ export class SmartFile extends plugins.smartjson.Smartjson {
     });
   }
 
-  public static async fromUrl (urlArg: string) {
+  public static async fromUrl(urlArg: string) {
     const response = await plugins.smartrequest.getBinary(urlArg);
     const smartfile = await SmartFile.fromBuffer(urlArg, response.body);
     return smartfile;
@@ -212,6 +212,43 @@ export class SmartFile extends plugins.smartjson.Smartjson {
     await fs.remove(plugins.path.join(this.base, this.path));
   }
 
+  /**
+   * Renames the file to the specified new name.
+   * - Updates the `path` property with the new name.
+   * - Writes the file to the new location if it exists on disk.
+   * @param newName The new name of the file (including extension if applicable).
+   * @param writeToDisk (optional) If true, also renames the file on the disk.
+   * @returns The updated file path after renaming.
+   */
+  public async rename(newName: string, writeToDisk: boolean = false): Promise<string> {
+    // Validate the new name
+    if (!newName || typeof newName !== 'string') {
+      throw new Error('Invalid new name provided.');
+    }
+
+    // Extract the directory path
+    const oldFilePath = this.path;
+    const dirPath = plugins.path.dirname(this.path);
+
+    // Create the new file path
+    const newFilePath = plugins.path.join(dirPath, newName);
+
+    // Update the `path` property
+    this.path = newFilePath;
+
+    // Optionally write the renamed file to disk
+    if (writeToDisk) {
+      const oldAbsolutePath = plugins.smartpath.transform.makeAbsolute(oldFilePath, this.base);
+      const newAbsolutePath = plugins.smartpath.transform.makeAbsolute(newFilePath, this.base);
+
+      // Rename the file on disk
+      await plugins.fsExtra.rename(oldAbsolutePath, newAbsolutePath);
+    }
+
+    // Return the new path
+    return this.path;
+  }
+
   // -----------------------------------------------
   // vinyl compatibility
   // -----------------------------------------------

ts/fs.ts

@@ -72,25 +72,23 @@ export const isFile = (pathArg): boolean => {
 ===============================================================*/
 
 /**
- * copies a file from A to B on the local disk
+ * copies a file or directory from A to B on the local disk
  */
-export const copy = async (fromArg: string, toArg: string): Promise<boolean> => {
+export const copy = async (fromArg: string, toArg: string, optionsArg?: plugins.fsExtra.CopyOptions & { replaceTargetDir?: boolean }): Promise<void> => {
-  const done = plugins.smartpromise.defer<boolean>();
+  if (optionsArg?.replaceTargetDir && isDirectory(fromArg) && isDirectory(toArg)) {
-  plugins.fsExtra.copy(fromArg, toArg, {}, (err) => {
+    await remove(toArg);
-    if (err) {
+  }
-      throw new Error(`Could not copy from ${fromArg} to ${toArg}: ${err}`);
+  return await plugins.fsExtra.copy(fromArg, toArg, optionsArg as plugins.fsExtra.CopyOptions);
-    }
-    done.resolve(true);
-  });
-  return done.promise;
 };
 
 /**
- * copies a file SYNCHRONOUSLY from A to B on the local disk
+ * copies a file or directory SYNCHRONOUSLY from A to B on the local disk
  */
-export const copySync = (fromArg: string, toArg: string): boolean => {
+export const copySync = (fromArg: string, toArg: string, optionsArg?: plugins.fsExtra.CopyOptionsSync & { replaceTargetDir?: boolean }): void => {
-  plugins.fsExtra.copySync(fromArg, toArg);
+  if (optionsArg?.replaceTargetDir && isDirectory(fromArg) && isDirectory(toArg)) {
-  return true;
+    removeSync(toArg);
+  }
+  return plugins.fsExtra.copySync(fromArg, toArg, optionsArg as plugins.fsExtra.CopyOptionsSync);
 };
 
 /**
@@ -200,7 +198,12 @@ export const toObjectSync = (filePathArg, fileTypeArg?) => {
   const fileString = plugins.fsExtra.readFileSync(filePathArg, 'utf8');
   let fileType;
   fileTypeArg ? (fileType = fileTypeArg) : (fileType = interpreter.filetype(filePathArg));
-  return interpreter.objectFile(fileString, fileType);
+  try {
+    return interpreter.objectFile(fileString, fileType);
+  } catch (err) {
+    err.message = `Failed to read file at ${filePathArg}` + err.message;
+    throw err;
+  }
 };
 
 /**
@@ -392,53 +395,174 @@ export const listFileTree = async (
 
 /**
  * Watches for file stability before resolving the promise.
+ * Ensures that the directory/file exists before setting up the watcher.
+ *
+ * **New behavior**: If the given path is a directory, this function will:
+ *  1. Wait for that directory to exist (creating a timeout if needed).
+ *  2. Watch the directory until at least one file appears.
+ *  3. Then wait for the first file in the directory to stabilize before resolving.
+ *
+ * @param fileOrDirPathArg The path of the file or directory to monitor.
+ * @param timeoutMs The maximum time to wait for the file to stabilize (in milliseconds). Default is 60 seconds.
+ * @returns A promise that resolves when the target is stable or rejects on timeout/error.
  */
-export const waitForFileToBeReady = (filePathArg: string): Promise<void> => {
+export const waitForFileToBeReady = async (
-  return new Promise(async (resolve, reject) => {
+  fileOrDirPathArg: string,
+  timeoutMs: number = 60000
+): Promise<void> => {
+  const startTime = Date.now();
+
+  /**
+   * Ensure that a path (file or directory) exists. If it doesn't yet exist,
+   * wait until it does (or time out).
+   * @param pathToCheck The file or directory path to check.
+   */
+  const ensurePathExists = async (pathToCheck: string): Promise<void> => {
+    while (true) {
+      try {
+        await plugins.smartpromise.fromCallback((cb) =>
+          plugins.fs.access(pathToCheck, plugins.fs.constants.F_OK, cb)
+        );
+        return;
+      } catch (err: any) {
+        if (err.code !== 'ENOENT') {
+          throw err; // Propagate unexpected errors
+        }
+        if (Date.now() - startTime > timeoutMs) {
+          throw new Error(`Timeout waiting for path to exist: ${pathToCheck}`);
+        }
+        await plugins.smartdelay.delayFor(500);
+      }
+    }
+  };
+
+  /**
+   * Checks if a file (not directory) is stable by comparing sizes
+   * across successive checks.
+   * @param filePathArg The path of the file to check.
+   * @returns A promise that resolves once the file stops changing.
+   */
+  const waitForSingleFileToBeStable = async (filePathArg: string): Promise<void> => {
     let lastFileSize = -1;
     let fileIsStable = false;
 
+    // We'll create a helper for repeated stats-checking logic
     const checkFileStability = async () => {
-      let currentFileSize: number;
+      try {
-      const deferred = plugins.smartpromise.defer();
+        const stats = await plugins.smartpromise.fromCallback<plugins.fs.Stats>((cb) =>
-      plugins.fs.stat(filePathArg, (err, stats) => {
+          plugins.fs.stat(filePathArg, cb)
-        if (err) {
+        );
-          fileIsStable = true;
+        if (stats.isDirectory()) {
-          watcher.close();
+          // If it unexpectedly turns out to be a directory here, throw
-          reject(err);
+          throw new Error(`Expected a file but found a directory: ${filePathArg}`);
-          return;
+        }
+        if (stats.size === lastFileSize) {
+          fileIsStable = true;
+        } else {
+          lastFileSize = stats.size;
+          fileIsStable = false;
+        }
+      } catch (err: any) {
+        // Ignore only if file not found
+        if (err.code !== 'ENOENT') {
+          throw err;
         }
-        currentFileSize = stats.size;
-        deferred.resolve();
-      });
-      await deferred.promise;
-      if (currentFileSize === lastFileSize) {
-        fileIsStable = true;
-        await plugins.smartdelay.delayFor(100);
-        resolve();
       }
-      lastFileSize = currentFileSize;
     };
 
-    const watcher = plugins.fs.watch(filePathArg, (eventType, filename) => {
+    // Ensure file exists first
-      if (eventType === 'change') {
+    await ensurePathExists(filePathArg);
-        checkFileStability();
+
+    // Set up a watcher on the file itself
+    const fileWatcher = plugins.fs.watch(filePathArg, { persistent: true }, async () => {
+      if (!fileIsStable) {
+        await checkFileStability();
       }
     });
 
-    watcher.on('error', (error) => {
+    try {
-      watcher.close();
+      // Poll until stable or timeout
-      reject(error);
+      while (!fileIsStable) {
-    });
+        if (Date.now() - startTime > timeoutMs) {
+          throw new Error(`Timeout waiting for file to stabilize: ${filePathArg}`);
+        }
+        await checkFileStability();
+        if (!fileIsStable) {
+          await plugins.smartdelay.delayFor(1000);
+        }
+      }
+    } finally {
+      fileWatcher.close();
+    }
+  };
 
-    while (!fileIsStable) {
+  /**
-      await checkFileStability();
+   * Main logic: check if we have a directory or file at fileOrDirPathArg.
-      if (!fileIsStable) {
+   * If directory, wait for first file in the directory to appear and stabilize.
-        await plugins.smartdelay.delayFor(5000);
+   * If file, do the old single-file wait logic.
+   */
+  const statsForGivenPath = await (async () => {
+    try {
+      await ensurePathExists(fileOrDirPathArg);
+      return await plugins.smartpromise.fromCallback<plugins.fs.Stats>((cb) =>
+        plugins.fs.stat(fileOrDirPathArg, cb)
+      );
+    } catch (err) {
+      // If there's an error (including timeout), just rethrow
+      throw err;
+    }
+  })();
+
+  if (!statsForGivenPath.isDirectory()) {
+    // It's a file – just do the single-file stability wait
+    await waitForSingleFileToBeStable(fileOrDirPathArg);
+    return;
+  }
+
+  // Otherwise, it's a directory. Wait for the first file inside to appear and be stable
+  const dirPath = fileOrDirPathArg;
+
+  // Helper to find the first file in the directory if it exists
+  const getFirstFileInDirectory = async (): Promise<string | null> => {
+    const entries = await plugins.smartpromise.fromCallback<string[]>((cb) =>
+      plugins.fs.readdir(dirPath, cb)
+    );
+    // We only want actual files, not subdirectories
+    for (const entry of entries) {
+      const entryPath = plugins.path.join(dirPath, entry);
+      const entryStats = await plugins.smartpromise.fromCallback<plugins.fs.Stats>((cb) =>
+        plugins.fs.stat(entryPath, cb)
+      );
+      if (entryStats.isFile()) {
+        return entryPath;
       }
     }
-    watcher.close();
+    return null;
-  });
+  };
+
+  // Wait for a file to appear in this directory
+  let firstFilePath = await getFirstFileInDirectory();
+  if (!firstFilePath) {
+    // Set up a watcher on the directory to see if a file appears
+    const directoryWatcher = plugins.fs.watch(dirPath, { persistent: true });
+    try {
+      // We'll poll for the existence of a file in that directory
+      while (!firstFilePath) {
+        if (Date.now() - startTime > timeoutMs) {
+          throw new Error(`Timeout waiting for a file to appear in directory: ${dirPath}`);
+        }
+        firstFilePath = await getFirstFileInDirectory();
+        if (!firstFilePath) {
+          await plugins.smartdelay.delayFor(1000);
+        }
+      }
+    } finally {
+      directoryWatcher.close();
+    }
+  }
+
+  // Now that we have a file path, wait for that file to stabilize
+  await waitForSingleFileToBeStable(firstFilePath);
 };
 
 /**
@@ -488,4 +612,4 @@ export let toFs = async (
 
 export const stat = async (filePathArg: string) => {
   return plugins.fsPromises.stat(filePathArg);
-}
+};