@jsenv/filesystem 4.2.2 → 4.2.4

package/src/writeEntryModificationTime.js

@@ -1,22 +1,22 @@
-import { utimes } from "node:fs"
+import { utimes } from "node:fs";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
 
 export const writeEntryModificationTime = (source, mtime) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source)
+  const sourceUrl = assertAndNormalizeFileUrl(source);
   const mtimeValue =
-    typeof mtime === "number" ? new Date(Math.floor(mtime)) : mtime
+    typeof mtime === "number" ? new Date(Math.floor(mtime)) : mtime;
   // reading atime mutates its value so there is no use case I can think of
   // where we want to modify it
-  const atimeValue = mtimeValue
+  const atimeValue = mtimeValue;
 
   return new Promise((resolve, reject) => {
     utimes(new URL(sourceUrl), atimeValue, mtimeValue, (error) => {
       if (error) {
-        reject(error)
+        reject(error);
       } else {
-        resolve()
+        resolve();
       }
-    })
-  })
-}
+    });
+  });
+};

package/src/writeEntryPermissions.js

@@ -1,12 +1,12 @@
-import { chmod } from "node:fs"
+import { chmod } from "node:fs";
 
-import { permissionsToBinaryFlags } from "./internal/permissions.js"
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
+import { permissionsToBinaryFlags } from "./internal/permissions.js";
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
 
 export const writeEntryPermissions = async (source, permissions) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source)
+  const sourceUrl = assertAndNormalizeFileUrl(source);
 
-  let binaryFlags
+  let binaryFlags;
   if (typeof permissions === "object") {
     permissions = {
       owner: {
@@ -28,58 +28,58 @@ export const writeEntryPermissions = async (source, permissions) => {
           permissions,
         ),
       },
-    }
-    binaryFlags = permissionsToBinaryFlags(permissions)
+    };
+    binaryFlags = permissionsToBinaryFlags(permissions);
   } else {
-    binaryFlags = permissions
+    binaryFlags = permissions;
   }
 
   return new Promise((resolve, reject) => {
     chmod(new URL(sourceUrl), binaryFlags, (error) => {
       if (error) {
-        reject(error)
+        reject(error);
       } else {
-        resolve()
+        resolve();
       }
-    })
-  })
-}
+    });
+  });
+};
 
-const actionLevels = { read: 0, write: 1, execute: 2 }
-const subjectLevels = { others: 0, group: 1, owner: 2 }
+const actionLevels = { read: 0, write: 1, execute: 2 };
+const subjectLevels = { others: 0, group: 1, owner: 2 };
 
 const getPermissionOrComputeDefault = (action, subject, permissions) => {
   if (subject in permissions) {
-    const subjectPermissions = permissions[subject]
+    const subjectPermissions = permissions[subject];
     if (action in subjectPermissions) {
-      return subjectPermissions[action]
+      return subjectPermissions[action];
     }
 
-    const actionLevel = actionLevels[action]
+    const actionLevel = actionLevels[action];
     const actionFallback = Object.keys(actionLevels).find(
       (actionFallbackCandidate) =>
         actionLevels[actionFallbackCandidate] > actionLevel &&
         actionFallbackCandidate in subjectPermissions,
-    )
+    );
     if (actionFallback) {
-      return subjectPermissions[actionFallback]
+      return subjectPermissions[actionFallback];
     }
   }
 
-  const subjectLevel = subjectLevels[subject]
+  const subjectLevel = subjectLevels[subject];
   // do we have a subject with a stronger level (group or owner)
   // where we could read the action permission ?
   const subjectFallback = Object.keys(subjectLevels).find(
     (subjectFallbackCandidate) =>
       subjectLevels[subjectFallbackCandidate] > subjectLevel &&
       subjectFallbackCandidate in permissions,
-  )
+  );
   if (subjectFallback) {
-    const subjectPermissions = permissions[subjectFallback]
+    const subjectPermissions = permissions[subjectFallback];
     return action in subjectPermissions
       ? subjectPermissions[action]
-      : getPermissionOrComputeDefault(action, subjectFallback, permissions)
+      : getPermissionOrComputeDefault(action, subjectFallback, permissions);
   }
 
-  return false
-}
+  return false;
+};

package/src/writeFile.js

@@ -1,31 +1,31 @@
-import { writeFile as writeFileNode } from "node:fs"
+import { writeFile as writeFileNode } from "node:fs";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
-import { ensureParentDirectories } from "./ensureParentDirectories.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { ensureParentDirectories } from "./ensureParentDirectories.js";
 
 export const writeFile = async (destination, content = "") => {
-  const destinationUrl = assertAndNormalizeFileUrl(destination)
-  const destinationUrlObject = new URL(destinationUrl)
+  const destinationUrl = assertAndNormalizeFileUrl(destination);
+  const destinationUrlObject = new URL(destinationUrl);
   try {
-    await writeFileNaive(destinationUrlObject, content)
+    await writeFileNaive(destinationUrlObject, content);
   } catch (error) {
     if (error.code === "ENOENT") {
-      await ensureParentDirectories(destinationUrl)
-      await writeFileNaive(destinationUrlObject, content)
-      return
+      await ensureParentDirectories(destinationUrl);
+      await writeFileNaive(destinationUrlObject, content);
+      return;
     }
-    throw error
+    throw error;
   }
-}
+};
 
 const writeFileNaive = (urlObject, content) => {
   return new Promise((resolve, reject) => {
     writeFileNode(urlObject, content, (error) => {
       if (error) {
-        reject(error)
+        reject(error);
       } else {
-        resolve()
+        resolve();
       }
-    })
-  })
-}
+    });
+  });
+};

package/src/writeFileSync.js

@@ -1,20 +1,20 @@
-import { writeFileSync as writeFileSyncNode, mkdirSync } from "node:fs"
+import { writeFileSync as writeFileSyncNode, mkdirSync } from "node:fs";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
 
 export const writeFileSync = (destination, content = "") => {
-  const destinationUrl = assertAndNormalizeFileUrl(destination)
-  const destinationUrlObject = new URL(destinationUrl)
+  const destinationUrl = assertAndNormalizeFileUrl(destination);
+  const destinationUrlObject = new URL(destinationUrl);
   try {
-    writeFileSyncNode(destinationUrlObject, content)
+    writeFileSyncNode(destinationUrlObject, content);
   } catch (error) {
     if (error.code === "ENOENT") {
       mkdirSync(new URL("./", destinationUrlObject), {
         recursive: true,
-      })
-      writeFileSyncNode(destinationUrlObject, content)
-      return
+      });
+      writeFileSyncNode(destinationUrlObject, content);
+      return;
     }
-    throw error
+    throw error;
   }
-}
+};

package/src/writeSymbolicLink.js

@@ -1,20 +1,20 @@
-import { promises } from "node:fs"
+import { promises } from "node:fs";
 import {
   fileSystemPathToUrl,
   urlToFileSystemPath,
   resolveUrl,
   isFileSystemPath,
-} from "@jsenv/urls"
+} from "@jsenv/urls";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
-import { ensureParentDirectories } from "./ensureParentDirectories.js"
-import { readEntryStat } from "./readEntryStat.js"
-import { readSymbolicLink } from "./readSymbolicLink.js"
-import { removeEntry } from "./removeEntry.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { ensureParentDirectories } from "./ensureParentDirectories.js";
+import { readEntryStat } from "./readEntryStat.js";
+import { readSymbolicLink } from "./readSymbolicLink.js";
+import { removeEntry } from "./removeEntry.js";
 
 // https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_fspromises_symlink_target_path_type
-const { symlink } = promises
-const isWindows = process.platform === "win32"
+const { symlink } = promises;
+const isWindows = process.platform === "win32";
 
 /**
  * Writes a symbolic link pointing from a filesystem node to an other
@@ -31,8 +31,8 @@ export const writeSymbolicLink = async ({
   allowUseless = false,
   allowOverwrite = false,
 }) => {
-  const fromUrl = assertAndNormalizeFileUrl(from)
-  const toInfo = getToInfo(to, fromUrl)
+  const fromUrl = assertAndNormalizeFileUrl(from);
+  const toInfo = getToInfo(to, fromUrl);
   // Node.js doc at https://nodejs.org/api/fs.html#fssymlinktarget-path-type-callback
   // states the following:
   // "If the type argument is not set, Node.js will autodetect
@@ -42,76 +42,76 @@ export const writeSymbolicLink = async ({
   if (isWindows && typeof type === "undefined") {
     const toStats = await readEntryStat(toInfo.url, {
       nullIfNotFound: true,
-    })
-    type = toStats && toStats.isDirectory() ? "dir" : "file"
+    });
+    type = toStats && toStats.isDirectory() ? "dir" : "file";
   }
-  const symbolicLinkPath = urlToFileSystemPath(fromUrl)
+  const symbolicLinkPath = urlToFileSystemPath(fromUrl);
   try {
-    await symlink(toInfo.value, symbolicLinkPath, type)
+    await symlink(toInfo.value, symbolicLinkPath, type);
   } catch (error) {
     if (error.code === "ENOENT") {
-      await ensureParentDirectories(fromUrl)
-      await symlink(toInfo.value, symbolicLinkPath, type)
-      return
+      await ensureParentDirectories(fromUrl);
+      await symlink(toInfo.value, symbolicLinkPath, type);
+      return;
     }
     if (error.code === "EEXIST") {
       if (allowUseless) {
-        const existingSymbolicLinkUrl = await readSymbolicLink(fromUrl)
+        const existingSymbolicLinkUrl = await readSymbolicLink(fromUrl);
         if (existingSymbolicLinkUrl === toInfo.url) {
-          return
+          return;
         }
       }
       if (allowOverwrite) {
-        await removeEntry(fromUrl)
-        await symlink(toInfo.value, symbolicLinkPath, type)
-        return
+        await removeEntry(fromUrl);
+        await symlink(toInfo.value, symbolicLinkPath, type);
+        return;
       }
     }
-    throw error
+    throw error;
   }
-}
+};
 
 const getToInfo = (to, fromUrl) => {
   if (typeof to === "string") {
     // absolute filesystem path
     if (isFileSystemPath(to)) {
-      const url = fileSystemPathToUrl(to)
-      const value = to
+      const url = fileSystemPathToUrl(to);
+      const value = to;
       return {
         url,
         value,
-      }
+      };
     }
 
     // relative url
     if (to.startsWith("./") || to.startsWith("../")) {
-      const url = resolveUrl(to, fromUrl)
-      const value = to
+      const url = resolveUrl(to, fromUrl);
+      const value = to;
       return {
         url,
         value,
-      }
+      };
     }
 
     // absolute url
-    const url = resolveUrl(to, fromUrl)
-    const value = urlToFileSystemPath(url)
+    const url = resolveUrl(to, fromUrl);
+    const value = urlToFileSystemPath(url);
     return {
       url,
       value,
-    }
+    };
   }
 
   if (to instanceof URL) {
-    const url = String(to)
-    const value = urlToFileSystemPath(url)
+    const url = String(to);
+    const value = urlToFileSystemPath(url);
     return {
       url,
       value,
-    }
+    };
   }
 
   throw new TypeError(
     `symbolic link to must be a string or an url, received ${to}`,
-  )
-}
+  );
+};