@jsenv/filesystem 4.2.3 → 4.2.5

package/src/moveDirectoryContent.js

@@ -1,13 +1,13 @@
-import { Abort } from "@jsenv/abort"
-import { urlToFileSystemPath, resolveUrl } from "@jsenv/urls"
+import { Abort } from "@jsenv/abort";
+import { urlToFileSystemPath, resolveUrl } from "@jsenv/urls";
 
-import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js"
-import { readEntryStat } from "./readEntryStat.js"
-import { readSymbolicLink } from "./readSymbolicLink.js"
-import { readDirectory } from "./readDirectory.js"
-import { moveEntry } from "./moveEntry.js"
-import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js"
-import { statsToType } from "./internal/statsToType.js"
+import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js";
+import { readEntryStat } from "./readEntryStat.js";
+import { readSymbolicLink } from "./readSymbolicLink.js";
+import { readDirectory } from "./readDirectory.js";
+import { moveEntry } from "./moveEntry.js";
+import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js";
+import { statsToType } from "./internal/statsToType.js";
 
 export const moveDirectoryContent = async ({
   signal = new AbortController().signal,
@@ -16,23 +16,23 @@ export const moveDirectoryContent = async ({
   overwrite,
   followLink = true,
 } = {}) => {
-  const fromUrl = assertAndNormalizeDirectoryUrl(from)
-  const fromPath = urlToFileSystemPath(fromUrl)
-  let toUrl = assertAndNormalizeDirectoryUrl(to)
-  let toPath = urlToFileSystemPath(toUrl)
+  const fromUrl = assertAndNormalizeDirectoryUrl(from);
+  const fromPath = urlToFileSystemPath(fromUrl);
+  let toUrl = assertAndNormalizeDirectoryUrl(to);
+  let toPath = urlToFileSystemPath(toUrl);
 
   const sourceStats = await readEntryStat(fromUrl, {
     nullIfNotFound: true,
     followLink: false,
-  })
+  });
   if (!sourceStats) {
-    throw new Error(`no directory to move content from at ${fromPath}`)
+    throw new Error(`no directory to move content from at ${fromPath}`);
   }
   if (!sourceStats.isDirectory()) {
-    const sourceType = statsToType(sourceStats)
+    const sourceType = statsToType(sourceStats);
     throw new Error(
       `found a ${sourceType} instead of a directory at ${fromPath}`,
-    )
+    );
   }
 
   let destinationStats = await readEntryStat(toUrl, {
@@ -40,41 +40,41 @@ export const moveDirectoryContent = async ({
     // we force false here but in fact we will follow the destination link
     // to know where we will actually move and detect useless move overrite etc..
     followLink: false,
-  })
+  });
   if (followLink && destinationStats && destinationStats.isSymbolicLink()) {
-    const linkTarget = await readSymbolicLink(toUrl)
-    toUrl = resolveUrl(linkTarget, toUrl)
-    toPath = urlToFileSystemPath(toUrl)
+    const linkTarget = await readSymbolicLink(toUrl);
+    toUrl = resolveUrl(linkTarget, toUrl);
+    toPath = urlToFileSystemPath(toUrl);
     destinationStats = await readEntryStat(toUrl, {
       nullIfNotFound: true,
-    })
+    });
   }
 
   if (destinationStats === null) {
-    throw new Error(`no directory to move content into at ${toPath}`)
+    throw new Error(`no directory to move content into at ${toPath}`);
   }
   if (!destinationStats.isDirectory()) {
-    const destinationType = statsToType(destinationStats)
+    const destinationType = statsToType(destinationStats);
     throw new Error(
       `destination leads to a ${destinationType} instead of a directory at ${toPath}`,
-    )
+    );
   }
 
   if (urlTargetsSameFileSystemPath(fromUrl, toUrl)) {
     throw new Error(
       `cannot move directory content, source and destination are the same (${fromPath})`,
-    )
+    );
   }
 
-  const moveOperation = Abort.startOperation()
-  moveOperation.addAbortSignal(signal)
+  const moveOperation = Abort.startOperation();
+  moveOperation.addAbortSignal(signal);
   try {
-    moveOperation.throwIfAborted()
-    const directoryEntries = await readDirectory(fromUrl)
+    moveOperation.throwIfAborted();
+    const directoryEntries = await readDirectory(fromUrl);
     await Promise.all(
       directoryEntries.map(async (directoryEntry) => {
-        const from = resolveUrl(directoryEntry, fromUrl)
-        const to = resolveUrl(directoryEntry, toUrl)
+        const from = resolveUrl(directoryEntry, fromUrl);
+        const to = resolveUrl(directoryEntry, toUrl);
 
         await moveOperation.withSignal(async (signal) => {
           await moveEntry({
@@ -83,11 +83,11 @@ export const moveDirectoryContent = async ({
             to,
             overwrite,
             followLink,
-          })
-        })
+          });
+        });
       }),
-    )
+    );
   } finally {
-    await moveOperation.end()
+    await moveOperation.end();
   }
-}
+};

package/src/moveEntry.js

@@ -1,15 +1,15 @@
-import { rename } from "node:fs"
-import { Abort } from "@jsenv/abort"
-import { urlToFileSystemPath, resolveUrl } from "@jsenv/urls"
+import { rename } from "node:fs";
+import { Abort } from "@jsenv/abort";
+import { urlToFileSystemPath, resolveUrl } from "@jsenv/urls";
 
-import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js"
-import { statsToType } from "./internal/statsToType.js"
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
-import { ensureParentDirectories } from "./ensureParentDirectories.js"
-import { removeEntry } from "./removeEntry.js"
-import { copyEntry } from "./copyEntry.js"
-import { readEntryStat } from "./readEntryStat.js"
-import { readSymbolicLink } from "./readSymbolicLink.js"
+import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js";
+import { statsToType } from "./internal/statsToType.js";
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { ensureParentDirectories } from "./ensureParentDirectories.js";
+import { removeEntry } from "./removeEntry.js";
+import { copyEntry } from "./copyEntry.js";
+import { readEntryStat } from "./readEntryStat.js";
+import { readSymbolicLink } from "./readSymbolicLink.js";
 
 export const moveEntry = async ({
   signal = new AbortController().signal,
@@ -19,17 +19,17 @@ export const moveEntry = async ({
   allowUseless = false,
   followLink = true,
 }) => {
-  const fromUrl = assertAndNormalizeFileUrl(from)
-  const fromPath = urlToFileSystemPath(fromUrl)
-  let toUrl = assertAndNormalizeFileUrl(to)
-  let toPath = urlToFileSystemPath(toUrl)
+  const fromUrl = assertAndNormalizeFileUrl(from);
+  const fromPath = urlToFileSystemPath(fromUrl);
+  let toUrl = assertAndNormalizeFileUrl(to);
+  let toPath = urlToFileSystemPath(toUrl);
 
   const sourceStats = await readEntryStat(fromUrl, {
     nullIfNotFound: true,
     followLink: false,
-  })
+  });
   if (!sourceStats) {
-    throw new Error(`nothing to move from ${fromPath}`)
+    throw new Error(`nothing to move from ${fromPath}`);
   }
 
   let destinationStats = await readEntryStat(toUrl, {
@@ -37,72 +37,72 @@ export const moveEntry = async ({
     // we force false here but in fact we will follow the destination link
     // to know where we will actually move and detect useless move overrite etc..
     followLink: false,
-  })
+  });
 
   if (followLink && destinationStats && destinationStats.isSymbolicLink()) {
-    const linkTarget = await readSymbolicLink(toUrl)
-    toUrl = resolveUrl(linkTarget, toUrl)
-    toPath = urlToFileSystemPath(toUrl)
+    const linkTarget = await readSymbolicLink(toUrl);
+    toUrl = resolveUrl(linkTarget, toUrl);
+    toPath = urlToFileSystemPath(toUrl);
     destinationStats = await readEntryStat(toUrl, {
       nullIfNotFound: true,
-    })
+    });
   }
 
   if (urlTargetsSameFileSystemPath(fromUrl, toUrl)) {
     if (allowUseless) {
-      return
+      return;
     }
     throw new Error(
       `no move needed for ${fromPath} because destination and source are the same`,
-    )
+    );
   }
 
-  const moveOperation = Abort.startOperation()
-  moveOperation.addAbortSignal(signal)
+  const moveOperation = Abort.startOperation();
+  moveOperation.addAbortSignal(signal);
 
   try {
     if (destinationStats) {
-      const sourceType = statsToType(sourceStats)
-      const destinationType = statsToType(destinationStats)
+      const sourceType = statsToType(sourceStats);
+      const destinationType = statsToType(destinationStats);
 
       if (sourceType !== destinationType) {
         throw new Error(
           `cannot move ${sourceType} from ${fromPath} to ${toPath} because destination exists and is not a ${sourceType} (it's a ${destinationType})`,
-        )
+        );
       }
       if (!overwrite) {
         throw new Error(
           `cannot move ${sourceType} from ${fromPath} to ${toPath} because destination exists and overwrite option is disabled`,
-        )
+        );
       }
 
       // remove file, link, directory...
       await removeEntry(toUrl, {
         signal: moveOperation.signal,
         recursive: true,
-      })
+      });
     } else {
-      await ensureParentDirectories(toUrl)
+      await ensureParentDirectories(toUrl);
     }
 
-    moveOperation.throwIfAborted()
+    moveOperation.throwIfAborted();
     await moveNaive(fromPath, toPath, {
       handleCrossDeviceError: async () => {
         await copyEntry({
           from: fromUrl,
           to: toUrl,
           preserveStat: true,
-        })
+        });
         await removeEntry(fromUrl, {
           signal: moveOperation.signal,
           recursive: true,
-        })
+        });
       },
-    })
+    });
   } finally {
-    await moveOperation.end()
+    await moveOperation.end();
   }
-}
+};
 
 const moveNaive = (
   fromPath,
@@ -113,13 +113,13 @@ const moveNaive = (
     rename(fromPath, destinationPath, (error) => {
       if (error) {
         if (handleCrossDeviceError && error.code === "EXDEV") {
-          resolve(handleCrossDeviceError(error))
+          resolve(handleCrossDeviceError(error));
         } else {
-          reject(error)
+          reject(error);
         }
       } else {
-        resolve()
+        resolve();
       }
-    })
-  })
-}
+    });
+  });
+};

package/src/readDirectory.js

@@ -1,39 +1,39 @@
-import { readdir } from "node:fs"
-import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js"
+import { readdir } from "node:fs";
+import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js";
 
 export const readDirectory = async (url, { emfileMaxWait = 1000 } = {}) => {
-  const directoryUrl = assertAndNormalizeDirectoryUrl(url)
-  const directoryUrlObject = new URL(directoryUrl)
-  const startMs = Date.now()
-  let attemptCount = 0
+  const directoryUrl = assertAndNormalizeDirectoryUrl(url);
+  const directoryUrlObject = new URL(directoryUrl);
+  const startMs = Date.now();
+  let attemptCount = 0;
 
   const attempt = async () => {
     try {
       const names = await new Promise((resolve, reject) => {
         readdir(directoryUrlObject, (error, names) => {
           if (error) {
-            reject(error)
+            reject(error);
           } else {
-            resolve(names)
+            resolve(names);
           }
-        })
-      })
-      return names.map(encodeURIComponent)
+        });
+      });
+      return names.map(encodeURIComponent);
     } catch (e) {
       // https://nodejs.org/dist/latest-v13.x/docs/api/errors.html#errors_common_system_errors
       if (e.code === "EMFILE" || e.code === "ENFILE") {
-        attemptCount++
-        const nowMs = Date.now()
-        const timeSpentWaiting = nowMs - startMs
+        attemptCount++;
+        const nowMs = Date.now();
+        const timeSpentWaiting = nowMs - startMs;
         if (timeSpentWaiting > emfileMaxWait) {
-          throw e
+          throw e;
         }
-        await new Promise((resolve) => setTimeout(resolve), attemptCount)
-        return await attempt()
+        await new Promise((resolve) => setTimeout(resolve), attemptCount);
+        return await attempt();
       }
-      throw e
+      throw e;
     }
-  }
+  };
 
-  return attempt()
-}
+  return attempt();
+};

package/src/readEntryModificationTime.js

@@ -1,6 +1,6 @@
-import { readEntryStat } from "./readEntryStat.js"
+import { readEntryStat } from "./readEntryStat.js";
 
 export const readEntryModificationTime = async (source) => {
-  const stats = await readEntryStat(source)
-  return Math.floor(stats.mtimeMs)
-}
+  const stats = await readEntryStat(source);
+  return Math.floor(stats.mtimeMs);
+};

package/src/readEntryPermissions.js

@@ -3,18 +3,18 @@
  *   https://nodejs.org/docs/latest-v13.x/api/fs.html#fs_file_modes
  */
 
-import { promises } from "node:fs"
-import { urlToFileSystemPath } from "@jsenv/urls"
+import { promises } from "node:fs";
+import { urlToFileSystemPath } from "@jsenv/urls";
 
-import { binaryFlagsToPermissions } from "./internal/permissions.js"
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
+import { binaryFlagsToPermissions } from "./internal/permissions.js";
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
 
-const { stat } = promises
+const { stat } = promises;
 
 export const readEntryPermissions = async (source) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source)
-  const sourcePath = urlToFileSystemPath(sourceUrl)
+  const sourceUrl = assertAndNormalizeFileUrl(source);
+  const sourcePath = urlToFileSystemPath(sourceUrl);
 
-  const { mode } = await stat(sourcePath)
-  return binaryFlagsToPermissions(mode)
-}
+  const { mode } = await stat(sourcePath);
+  return binaryFlagsToPermissions(mode);
+};

package/src/readEntryStat.js

@@ -3,28 +3,28 @@
  *   https://nodejs.org/docs/latest-v13.x/api/fs.html#fs_class_fs_stats
  */
 
-import { lstat, stat } from "node:fs"
-import { urlToFileSystemPath } from "@jsenv/urls"
+import { lstat, stat } from "node:fs";
+import { urlToFileSystemPath } from "@jsenv/urls";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
-import { writeEntryPermissions } from "./writeEntryPermissions.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { writeEntryPermissions } from "./writeEntryPermissions.js";
 
-const isWindows = process.platform === "win32"
+const isWindows = process.platform === "win32";
 
 export const readEntryStat = async (
   source,
   { nullIfNotFound = false, followLink = true } = {},
 ) => {
-  let sourceUrl = assertAndNormalizeFileUrl(source)
-  if (sourceUrl.endsWith("/")) sourceUrl = sourceUrl.slice(0, -1)
+  let sourceUrl = assertAndNormalizeFileUrl(source);
+  if (sourceUrl.endsWith("/")) sourceUrl = sourceUrl.slice(0, -1);
 
-  const sourcePath = urlToFileSystemPath(sourceUrl)
+  const sourcePath = urlToFileSystemPath(sourceUrl);
 
   const handleNotFoundOption = nullIfNotFound
     ? {
         handleNotFoundError: () => null,
       }
-    : {}
+    : {};
 
   return readStat(sourcePath, {
     followLink,
@@ -35,34 +35,34 @@ export const readEntryStat = async (
           handlePermissionDeniedError: async (error) => {
             console.error(
               `trying to fix windows EPERM after stats on ${sourcePath}`,
-            )
+            );
 
             try {
               // unfortunately it means we mutate the permissions
               // without being able to restore them to the previous value
               // (because reading current permission would also throw)
-              await writeEntryPermissions(sourceUrl, 0o666)
+              await writeEntryPermissions(sourceUrl, 0o666);
               const stats = await readStat(sourcePath, {
                 followLink,
                 ...handleNotFoundOption,
                 // could not fix the permission error, give up and throw original error
                 handlePermissionDeniedError: () => {
-                  console.error(`still got EPERM after stats on ${sourcePath}`)
-                  throw error
+                  console.error(`still got EPERM after stats on ${sourcePath}`);
+                  throw error;
                 },
-              })
-              return stats
+              });
+              return stats;
             } catch (e) {
               console.error(
                 `error while trying to fix windows EPERM after stats on ${sourcePath}: ${e.stack}`,
-              )
-              throw error
+              );
+              throw error;
             }
           },
         }
       : {}),
-  })
-}
+  });
+};
 
 const readStat = (
   sourcePath,
@@ -72,24 +72,24 @@ const readStat = (
     handlePermissionDeniedError = null,
   } = {},
 ) => {
-  const nodeMethod = followLink ? stat : lstat
+  const nodeMethod = followLink ? stat : lstat;
 
   return new Promise((resolve, reject) => {
     nodeMethod(sourcePath, (error, statsObject) => {
       if (error) {
         if (handleNotFoundError && error.code === "ENOENT") {
-          resolve(handleNotFoundError(error))
+          resolve(handleNotFoundError(error));
         } else if (
           handlePermissionDeniedError &&
           (error.code === "EPERM" || error.code === "EACCES")
         ) {
-          resolve(handlePermissionDeniedError(error))
+          resolve(handlePermissionDeniedError(error));
         } else {
-          reject(error)
+          reject(error);
         }
       } else {
-        resolve(statsObject)
+        resolve(statsObject);
       }
-    })
-  })
-}
+    });
+  });
+};

package/src/readFile.js

@@ -1,28 +1,28 @@
-import { readFile as readFileNode } from "node:fs"
+import { readFile as readFileNode } from "node:fs";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
 
 export const readFile = async (value, { as = "buffer" } = {}) => {
-  const fileUrl = assertAndNormalizeFileUrl(value)
+  const fileUrl = assertAndNormalizeFileUrl(value);
   const buffer = await new Promise((resolve, reject) => {
     readFileNode(new URL(fileUrl), (error, buffer) => {
       if (error) {
-        reject(error)
+        reject(error);
       } else {
-        resolve(buffer)
+        resolve(buffer);
       }
-    })
-  })
+    });
+  });
   if (as === "buffer") {
-    return buffer
+    return buffer;
   }
   if (as === "string") {
-    return buffer.toString()
+    return buffer.toString();
   }
   if (as === "json") {
-    return JSON.parse(buffer.toString())
+    return JSON.parse(buffer.toString());
   }
   throw new Error(
     `"as" must be one of "buffer","string","json" received "${as}"`,
-  )
-}
+  );
+};

package/src/readFileSync.js

@@ -1,20 +1,20 @@
-import { readFileSync as readFileSyncNode } from "node:fs"
+import { readFileSync as readFileSyncNode } from "node:fs";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
 
 export const readFileSync = (value, { as = "buffer" } = {}) => {
-  const fileUrl = assertAndNormalizeFileUrl(value)
-  const buffer = readFileSyncNode(new URL(fileUrl))
+  const fileUrl = assertAndNormalizeFileUrl(value);
+  const buffer = readFileSyncNode(new URL(fileUrl));
   if (as === "buffer") {
-    return buffer
+    return buffer;
   }
   if (as === "string") {
-    return buffer.toString()
+    return buffer.toString();
   }
   if (as === "json") {
-    return JSON.parse(buffer.toString())
+    return JSON.parse(buffer.toString());
   }
   throw new Error(
     `"as" must be one of "buffer","string","json" received "${as}"`,
-  )
-}
+  );
+};

package/src/readSymbolicLink.js

@@ -3,25 +3,25 @@
  *   https://nodejs.org/docs/latest-v13.x/api/fs.html#fs_fs_symlink_target_path_type_callback
  */
 
-import { readlink } from "node:fs"
-import { isFileSystemPath, fileSystemPathToUrl } from "@jsenv/urls"
+import { readlink } from "node:fs";
+import { isFileSystemPath, fileSystemPathToUrl } from "@jsenv/urls";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
 
 export const readSymbolicLink = (url) => {
-  const symbolicLinkUrl = assertAndNormalizeFileUrl(url)
+  const symbolicLinkUrl = assertAndNormalizeFileUrl(url);
 
   return new Promise((resolve, reject) => {
     readlink(new URL(symbolicLinkUrl), (error, resolvedPath) => {
       if (error) {
-        reject(error)
+        reject(error);
       } else {
         resolve(
           isFileSystemPath(resolvedPath)
             ? fileSystemPathToUrl(resolvedPath)
             : resolvedPath.replace(/\\/g, "/"), // replace back slashes with slashes
-        )
+        );
       }
-    })
-  })
-}
+    });
+  });
+};