@jsenv/filesystem 4.2.3 → 4.2.5

package/src/registerFileLifecycle.js

@@ -1,12 +1,12 @@
-import { statSync } from "node:fs"
-import { dirname, basename } from "node:path"
-import { urlToFileSystemPath } from "@jsenv/urls"
+import { statSync } from "node:fs";
+import { dirname, basename } from "node:path";
+import { urlToFileSystemPath } from "@jsenv/urls";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
-import { guardTooFastSecondCall } from "./internal/guard_second_call.js"
-import { statsToType } from "./internal/statsToType.js"
-import { createWatcher } from "./internal/createWatcher.js"
-import { trackResources } from "./internal/track_resources.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { guardTooFastSecondCall } from "./internal/guard_second_call.js";
+import { statsToType } from "./internal/statsToType.js";
+import { createWatcher } from "./internal/createWatcher.js";
+import { trackResources } from "./internal/track_resources.js";
 
 export const registerFileLifecycle = (
   source,
@@ -19,138 +19,138 @@ export const registerFileLifecycle = (
     cooldownBetweenFileEvents = 0,
   },
 ) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source)
+  const sourceUrl = assertAndNormalizeFileUrl(source);
   if (!undefinedOrFunction(added)) {
-    throw new TypeError(`added must be a function or undefined, got ${added}`)
+    throw new TypeError(`added must be a function or undefined, got ${added}`);
   }
   if (!undefinedOrFunction(updated)) {
     throw new TypeError(
       `updated must be a function or undefined, got ${updated}`,
-    )
+    );
   }
   if (!undefinedOrFunction(removed)) {
     throw new TypeError(
       `removed must be a function or undefined, got ${removed}`,
-    )
+    );
   }
   if (cooldownBetweenFileEvents) {
     if (added) {
-      added = guardTooFastSecondCall(added, cooldownBetweenFileEvents)
+      added = guardTooFastSecondCall(added, cooldownBetweenFileEvents);
     }
     if (updated) {
-      updated = guardTooFastSecondCall(updated, cooldownBetweenFileEvents)
+      updated = guardTooFastSecondCall(updated, cooldownBetweenFileEvents);
     }
     if (removed) {
-      removed = guardTooFastSecondCall(removed, cooldownBetweenFileEvents)
+      removed = guardTooFastSecondCall(removed, cooldownBetweenFileEvents);
     }
   }
 
-  const tracker = trackResources()
+  const tracker = trackResources();
 
   const handleFileFound = ({ existent }) => {
     const fileMutationStopWatching = watchFileMutation(sourceUrl, {
       updated,
       removed: () => {
-        fileMutationStopTracking()
-        watchFileAdded()
+        fileMutationStopTracking();
+        watchFileAdded();
         if (removed) {
-          removed()
+          removed();
         }
       },
       keepProcessAlive,
-    })
+    });
     const fileMutationStopTracking = tracker.registerCleanupCallback(
       fileMutationStopWatching,
-    )
+    );
 
     if (added) {
       if (existent) {
         if (notifyExistent) {
-          added({ existent: true })
+          added({ existent: true });
         }
       } else {
-        added({})
+        added({});
       }
     }
-  }
+  };
 
   const watchFileAdded = () => {
     const fileCreationStopWatching = watchFileCreation(
       sourceUrl,
       () => {
-        fileCreationgStopTracking()
-        handleFileFound({ existent: false })
+        fileCreationgStopTracking();
+        handleFileFound({ existent: false });
       },
       keepProcessAlive,
-    )
+    );
     const fileCreationgStopTracking = tracker.registerCleanupCallback(
       fileCreationStopWatching,
-    )
-  }
+    );
+  };
 
-  const sourceType = entryToTypeOrNull(sourceUrl)
+  const sourceType = entryToTypeOrNull(sourceUrl);
   if (sourceType === null) {
     if (added) {
-      watchFileAdded()
+      watchFileAdded();
     } else {
       throw new Error(
         `${urlToFileSystemPath(sourceUrl)} must lead to a file, found nothing`,
-      )
+      );
     }
   } else if (sourceType === "file") {
-    handleFileFound({ existent: true })
+    handleFileFound({ existent: true });
   } else {
     throw new Error(
       `${urlToFileSystemPath(
         sourceUrl,
       )} must lead to a file, type found instead`,
-    )
+    );
   }
 
-  return tracker.cleanup
-}
+  return tracker.cleanup;
+};
 
 const entryToTypeOrNull = (url) => {
   try {
-    const stats = statSync(new URL(url))
-    return statsToType(stats)
+    const stats = statSync(new URL(url));
+    return statsToType(stats);
   } catch (e) {
     if (e.code === "ENOENT") {
-      return null
+      return null;
     }
-    throw e
+    throw e;
   }
-}
+};
 
 const undefinedOrFunction = (value) =>
-  typeof value === "undefined" || typeof value === "function"
+  typeof value === "undefined" || typeof value === "function";
 
 const watchFileCreation = (source, callback, keepProcessAlive) => {
-  const sourcePath = urlToFileSystemPath(source)
-  const sourceFilename = basename(sourcePath)
-  const directoryPath = dirname(sourcePath)
+  const sourcePath = urlToFileSystemPath(source);
+  const sourceFilename = basename(sourcePath);
+  const directoryPath = dirname(sourcePath);
   let directoryWatcher = createWatcher(directoryPath, {
     persistent: keepProcessAlive,
-  })
+  });
   directoryWatcher.on("change", (eventType, filename) => {
-    if (filename && filename !== sourceFilename) return
+    if (filename && filename !== sourceFilename) return;
 
-    const type = entryToTypeOrNull(source)
+    const type = entryToTypeOrNull(source);
     // ignore if something else with that name gets created
     // we are only interested into files
-    if (type !== "file") return
+    if (type !== "file") return;
 
-    directoryWatcher.close()
-    directoryWatcher = undefined
-    callback()
-  })
+    directoryWatcher.close();
+    directoryWatcher = undefined;
+    callback();
+  });
 
   return () => {
     if (directoryWatcher) {
-      directoryWatcher.close()
+      directoryWatcher.close();
     }
-  }
-}
+  };
+};
 
 const watchFileMutation = (
   sourceUrl,
@@ -158,27 +158,27 @@ const watchFileMutation = (
 ) => {
   let watcher = createWatcher(urlToFileSystemPath(sourceUrl), {
     persistent: keepProcessAlive,
-  })
+  });
 
   watcher.on("change", () => {
-    const sourceType = entryToTypeOrNull(sourceUrl)
+    const sourceType = entryToTypeOrNull(sourceUrl);
 
     if (sourceType === null) {
-      watcher.close()
-      watcher = undefined
+      watcher.close();
+      watcher = undefined;
       if (removed) {
-        removed()
+        removed();
       }
     } else if (sourceType === "file") {
       if (updated) {
-        updated()
+        updated();
       }
     }
-  })
+  });
 
   return () => {
     if (watcher) {
-      watcher.close()
+      watcher.close();
     }
-  }
-}
+  };
+};

package/src/removeEntry.js

@@ -1,14 +1,14 @@
-import { unlink, rmdir, openSync, closeSync } from "node:fs"
-import { Abort } from "@jsenv/abort"
+import { unlink, rmdir, openSync, closeSync } from "node:fs";
+import { Abort } from "@jsenv/abort";
 import {
   ensurePathnameTrailingSlash,
   urlToFileSystemPath,
   resolveUrl,
-} from "@jsenv/urls"
+} from "@jsenv/urls";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
-import { readEntryStat } from "./readEntryStat.js"
-import { readDirectory } from "./readDirectory.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { readEntryStat } from "./readEntryStat.js";
+import { readDirectory } from "./readDirectory.js";
 
 export const removeEntry = async (
   source,
@@ -21,22 +21,22 @@ export const removeEntry = async (
     onlyContent = false,
   } = {},
 ) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source)
+  const sourceUrl = assertAndNormalizeFileUrl(source);
 
-  const removeOperation = Abort.startOperation()
-  removeOperation.addAbortSignal(signal)
+  const removeOperation = Abort.startOperation();
+  removeOperation.addAbortSignal(signal);
 
   try {
-    removeOperation.throwIfAborted()
+    removeOperation.throwIfAborted();
     const sourceStats = await readEntryStat(sourceUrl, {
       nullIfNotFound: true,
       followLink: false,
-    })
+    });
     if (!sourceStats) {
       if (allowUseless) {
-        return
+        return;
       }
-      throw new Error(`nothing to remove at ${urlToFileSystemPath(sourceUrl)}`)
+      throw new Error(`nothing to remove at ${urlToFileSystemPath(sourceUrl)}`);
     }
 
     // https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_class_fs_stats
@@ -54,7 +54,7 @@ export const removeEntry = async (
           maxRetries,
           retryDelay,
         },
-      )
+      );
     } else if (sourceStats.isDirectory()) {
       await removeDirectory(ensurePathnameTrailingSlash(sourceUrl), {
         signal: removeOperation.signal,
@@ -62,42 +62,42 @@ export const removeEntry = async (
         maxRetries,
         retryDelay,
         onlyContent,
-      })
+      });
     }
   } finally {
-    await removeOperation.end()
+    await removeOperation.end();
   }
-}
+};
 
 const removeNonDirectory = (sourceUrl, { maxRetries, retryDelay }) => {
-  const sourcePath = urlToFileSystemPath(sourceUrl)
+  const sourcePath = urlToFileSystemPath(sourceUrl);
 
-  let retryCount = 0
+  let retryCount = 0;
   const attempt = () => {
     return unlinkNaive(sourcePath, {
       ...(retryCount >= maxRetries
         ? {}
         : {
             handleTemporaryError: async () => {
-              retryCount++
+              retryCount++;
               return new Promise((resolve) => {
                 setTimeout(() => {
-                  resolve(attempt())
-                }, retryCount * retryDelay)
-              })
+                  resolve(attempt());
+                }, retryCount * retryDelay);
+              });
             },
           }),
-    })
-  }
-  return attempt()
-}
+    });
+  };
+  return attempt();
+};
 
 const unlinkNaive = (sourcePath, { handleTemporaryError = null } = {}) => {
   return new Promise((resolve, reject) => {
     unlink(sourcePath, (error) => {
       if (error) {
         if (error.code === "ENOENT") {
-          resolve()
+          resolve();
         } else if (
           handleTemporaryError &&
           (error.code === "EBUSY" ||
@@ -105,34 +105,34 @@ const unlinkNaive = (sourcePath, { handleTemporaryError = null } = {}) => {
             error.code === "ENFILE" ||
             error.code === "ENOENT")
         ) {
-          resolve(handleTemporaryError(error))
+          resolve(handleTemporaryError(error));
         } else {
-          reject(error)
+          reject(error);
         }
       } else {
-        resolve()
+        resolve();
       }
-    })
-  })
-}
+    });
+  });
+};
 
 const removeDirectory = async (
   rootDirectoryUrl,
   { signal, maxRetries, retryDelay, recursive, onlyContent },
 ) => {
-  const removeDirectoryOperation = Abort.startOperation()
-  removeDirectoryOperation.addAbortSignal(signal)
+  const removeDirectoryOperation = Abort.startOperation();
+  removeDirectoryOperation.addAbortSignal(signal);
 
   const visit = async (sourceUrl) => {
-    removeDirectoryOperation.throwIfAborted()
+    removeDirectoryOperation.throwIfAborted();
     const sourceStats = await readEntryStat(sourceUrl, {
       nullIfNotFound: true,
       followLink: false,
-    })
+    });
 
     // file/directory not found
     if (sourceStats === null) {
-      return
+      return;
     }
 
     if (
@@ -140,25 +140,25 @@ const removeDirectory = async (
       sourceStats.isCharacterDevice() ||
       sourceStats.isBlockDevice()
     ) {
-      await visitFile(sourceUrl)
+      await visitFile(sourceUrl);
     } else if (sourceStats.isSymbolicLink()) {
-      await visitSymbolicLink(sourceUrl)
+      await visitSymbolicLink(sourceUrl);
     } else if (sourceStats.isDirectory()) {
-      await visitDirectory(`${sourceUrl}/`)
+      await visitDirectory(`${sourceUrl}/`);
     }
-  }
+  };
 
   const visitDirectory = async (directoryUrl) => {
-    const directoryPath = urlToFileSystemPath(directoryUrl)
+    const directoryPath = urlToFileSystemPath(directoryUrl);
     const optionsFromRecursive = recursive
       ? {
           handleNotEmptyError: async () => {
-            await removeDirectoryContent(directoryUrl)
-            await visitDirectory(directoryUrl)
+            await removeDirectoryContent(directoryUrl);
+            await visitDirectory(directoryUrl);
           },
         }
-      : {}
-    removeDirectoryOperation.throwIfAborted()
+      : {};
+    removeDirectoryOperation.throwIfAborted();
     await removeDirectoryNaive(directoryPath, {
       ...optionsFromRecursive,
       // Workaround for https://github.com/joyent/node/issues/4337
@@ -167,64 +167,64 @@ const removeDirectory = async (
             handlePermissionError: async (error) => {
               console.error(
                 `trying to fix windows EPERM after readir on ${directoryPath}`,
-              )
+              );
 
-              let openOrCloseError
+              let openOrCloseError;
               try {
-                const fd = openSync(directoryPath)
-                closeSync(fd)
+                const fd = openSync(directoryPath);
+                closeSync(fd);
               } catch (e) {
-                openOrCloseError = e
+                openOrCloseError = e;
               }
 
               if (openOrCloseError) {
                 if (openOrCloseError.code === "ENOENT") {
-                  return
+                  return;
                 }
                 console.error(
                   `error while trying to fix windows EPERM after readir on ${directoryPath}: ${openOrCloseError.stack}`,
-                )
-                throw error
+                );
+                throw error;
               }
 
               await removeDirectoryNaive(directoryPath, {
                 ...optionsFromRecursive,
-              })
+              });
             },
           }
         : {}),
-    })
-  }
+    });
+  };
 
   const removeDirectoryContent = async (directoryUrl) => {
-    removeDirectoryOperation.throwIfAborted()
-    const names = await readDirectory(directoryUrl)
+    removeDirectoryOperation.throwIfAborted();
+    const names = await readDirectory(directoryUrl);
     await Promise.all(
       names.map(async (name) => {
-        const url = resolveUrl(name, directoryUrl)
-        await visit(url)
+        const url = resolveUrl(name, directoryUrl);
+        await visit(url);
       }),
-    )
-  }
+    );
+  };
 
   const visitFile = async (fileUrl) => {
-    await removeNonDirectory(fileUrl, { maxRetries, retryDelay })
-  }
+    await removeNonDirectory(fileUrl, { maxRetries, retryDelay });
+  };
 
   const visitSymbolicLink = async (symbolicLinkUrl) => {
-    await removeNonDirectory(symbolicLinkUrl, { maxRetries, retryDelay })
-  }
+    await removeNonDirectory(symbolicLinkUrl, { maxRetries, retryDelay });
+  };
 
   try {
     if (onlyContent) {
-      await removeDirectoryContent(rootDirectoryUrl)
+      await removeDirectoryContent(rootDirectoryUrl);
     } else {
-      await visitDirectory(rootDirectoryUrl)
+      await visitDirectory(rootDirectoryUrl);
     }
   } finally {
-    await removeDirectoryOperation.end()
+    await removeDirectoryOperation.end();
   }
-}
+};
 
 const removeDirectoryNaive = (
   directoryPath,
@@ -234,9 +234,9 @@ const removeDirectoryNaive = (
     rmdir(directoryPath, (error, lstatObject) => {
       if (error) {
         if (handlePermissionError && error.code === "EPERM") {
-          resolve(handlePermissionError(error))
+          resolve(handlePermissionError(error));
         } else if (error.code === "ENOENT") {
-          resolve()
+          resolve();
         } else if (
           handleNotEmptyError &&
           // linux os
@@ -244,13 +244,13 @@ const removeDirectoryNaive = (
             // SunOS
             error.code === "EEXIST")
         ) {
-          resolve(handleNotEmptyError(error))
+          resolve(handleNotEmptyError(error));
         } else {
-          reject(error)
+          reject(error);
         }
       } else {
-        resolve(lstatObject)
+        resolve(lstatObject);
       }
-    })
-  })
-}
+    });
+  });
+};

package/src/testEntryPermissions.js

@@ -1,14 +1,14 @@
-import { promises, constants } from "node:fs"
+import { promises, constants } from "node:fs";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
 
-const { access } = promises
+const { access } = promises;
 const {
   // F_OK,
   R_OK,
   W_OK,
   X_OK,
-} = constants
+} = constants;
 
 export const testEntryPermissions = async (
   source,
@@ -19,24 +19,24 @@ export const testEntryPermissions = async (
     allowedIfNotFound = false,
   } = {},
 ) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source)
-  let binaryFlags = 0
+  const sourceUrl = assertAndNormalizeFileUrl(source);
+  let binaryFlags = 0;
 
   // if (visible) binaryFlags |= F_OK
-  if (read) binaryFlags |= R_OK
-  if (write) binaryFlags |= W_OK
-  if (execute) binaryFlags |= X_OK
+  if (read) binaryFlags |= R_OK;
+  if (write) binaryFlags |= W_OK;
+  if (execute) binaryFlags |= X_OK;
 
   try {
-    await access(new URL(sourceUrl), binaryFlags)
-    return true
+    await access(new URL(sourceUrl), binaryFlags);
+    return true;
   } catch (error) {
     if (error.code === "ENOENT") {
       if (allowedIfNotFound) {
-        return true
+        return true;
       }
-      throw error
+      throw error;
     }
-    return false
+    return false;
   }
-}
+};

package/src/writeDirectory.js

@@ -1,45 +1,45 @@
-import { promises } from "node:fs"
-import { urlToFileSystemPath } from "@jsenv/urls"
+import { promises } from "node:fs";
+import { urlToFileSystemPath } from "@jsenv/urls";
 
-import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js"
-import { statsToType } from "./internal/statsToType.js"
-import { readEntryStat } from "./readEntryStat.js"
+import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js";
+import { statsToType } from "./internal/statsToType.js";
+import { readEntryStat } from "./readEntryStat.js";
 
 // https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_fspromises_mkdir_path_options
-const { mkdir } = promises
+const { mkdir } = promises;
 
 export const writeDirectory = async (
   destination,
   { recursive = true, allowUseless = false } = {},
 ) => {
-  const destinationUrl = assertAndNormalizeDirectoryUrl(destination)
-  const destinationPath = urlToFileSystemPath(destinationUrl)
+  const destinationUrl = assertAndNormalizeDirectoryUrl(destination);
+  const destinationPath = urlToFileSystemPath(destinationUrl);
 
   const destinationStats = await readEntryStat(destinationUrl, {
     nullIfNotFound: true,
     followLink: false,
-  })
+  });
 
   if (destinationStats) {
     if (destinationStats.isDirectory()) {
       if (allowUseless) {
-        return
+        return;
       }
-      throw new Error(`directory already exists at ${destinationPath}`)
+      throw new Error(`directory already exists at ${destinationPath}`);
     }
 
-    const destinationType = statsToType(destinationStats)
+    const destinationType = statsToType(destinationStats);
     throw new Error(
       `cannot write directory at ${destinationPath} because there is a ${destinationType}`,
-    )
+    );
   }
 
   try {
-    await mkdir(destinationPath, { recursive })
+    await mkdir(destinationPath, { recursive });
   } catch (error) {
     if (allowUseless && error.code === "EEXIST") {
-      return
+      return;
     }
-    throw error
+    throw error;
   }
-}
+};