@jsenv/filesystem 4.2.2 → 4.2.4

package/src/file_url_validation.js

@@ -1,22 +1,22 @@
-import { fileSystemPathToUrl, isFileSystemPath } from "@jsenv/urls"
+import { fileSystemPathToUrl, isFileSystemPath } from "@jsenv/urls";
 
 export const validateFileUrl = (value, baseUrl) => {
-  let urlString
+  let urlString;
 
   if (value instanceof URL) {
-    urlString = value.href
+    urlString = value.href;
   } else if (typeof value === "string") {
     if (isFileSystemPath(value)) {
-      urlString = fileSystemPathToUrl(value)
+      urlString = fileSystemPathToUrl(value);
     } else {
       try {
-        urlString = String(new URL(value, baseUrl))
+        urlString = String(new URL(value, baseUrl));
       } catch (e) {
         return {
           valid: false,
           value,
           message: "must be a valid url",
-        }
+        };
       }
     }
   } else {
@@ -24,7 +24,7 @@ export const validateFileUrl = (value, baseUrl) => {
       valid: false,
       value,
       message: "must be a string or an url",
-    }
+    };
   }
 
   if (!urlString.startsWith("file://")) {
@@ -32,23 +32,23 @@ export const validateFileUrl = (value, baseUrl) => {
       valid: false,
       value,
       message: 'must start with "file://"',
-    }
+    };
   }
 
   return {
     valid: true,
     value: urlString,
-  }
-}
+  };
+};
 
 export const assertAndNormalizeFileUrl = (
   fileUrl,
   baseUrl,
   name = "fileUrl",
 ) => {
-  const { valid, message, value } = validateFileUrl(fileUrl, baseUrl)
+  const { valid, message, value } = validateFileUrl(fileUrl, baseUrl);
   if (!valid) {
-    throw new TypeError(`${name} ${message}, got ${fileUrl}`)
+    throw new TypeError(`${name} ${message}, got ${fileUrl}`);
   }
-  return value
-}
+  return value;
+};

package/src/getRealFileSystemUrlSync.js

@@ -1,57 +1,57 @@
-import { readdirSync, realpathSync } from "node:fs"
-import { fileSystemPathToUrl, urlToFileSystemPath } from "@jsenv/urls"
+import { readdirSync, realpathSync } from "node:fs";
+import { fileSystemPathToUrl, urlToFileSystemPath } from "@jsenv/urls";
 
 export const getRealFileSystemUrlSync = (
   fileUrl,
   { followLink = true } = {},
 ) => {
-  const pathname = new URL(fileUrl).pathname
-  const parts = pathname.slice(1).split("/")
-  let reconstructedFileUrl = `file:///`
+  const pathname = new URL(fileUrl).pathname;
+  const parts = pathname.slice(1).split("/");
+  let reconstructedFileUrl = `file:///`;
   if (process.platform === "win32") {
-    const windowsDriveLetter = parts.shift()
-    reconstructedFileUrl += `${windowsDriveLetter}/`
+    const windowsDriveLetter = parts.shift();
+    reconstructedFileUrl += `${windowsDriveLetter}/`;
   }
-  let i = 0
+  let i = 0;
   // eslint-disable-next-line no-constant-condition
   while (true) {
-    const name = parts[i]
-    i++
-    let namesOnFileSystem
+    const name = parts[i];
+    i++;
+    let namesOnFileSystem;
     try {
       namesOnFileSystem = readdirSync(
         // When Node.js receives "C:/" on windows it returns
         // the process.cwd() directory content...
         // This can be fixed by passing "file:///C:/" directly but as a url object
         new URL(reconstructedFileUrl),
-      )
+      );
     } catch (e) {
       if (e && e.code === "ENOENT") {
-        return null
+        return null;
       }
-      throw e
+      throw e;
     }
-    const foundOnFilesystem = namesOnFileSystem.includes(name)
+    const foundOnFilesystem = namesOnFileSystem.includes(name);
     if (foundOnFilesystem) {
-      reconstructedFileUrl += name
+      reconstructedFileUrl += name;
     } else {
       const nameOnFileSystem = namesOnFileSystem.find(
         (nameCandidate) => nameCandidate.toLowerCase() === name.toLowerCase(),
-      )
+      );
       if (!nameOnFileSystem) {
-        return null
+        return null;
       }
-      reconstructedFileUrl += nameOnFileSystem
+      reconstructedFileUrl += nameOnFileSystem;
     }
     if (i === parts.length) {
       if (followLink) {
         const realPath = realpathSync.native(
           urlToFileSystemPath(reconstructedFileUrl),
-        )
-        return fileSystemPathToUrl(realPath)
+        );
+        return fileSystemPathToUrl(realPath);
       }
-      return reconstructedFileUrl
+      return reconstructedFileUrl;
     }
-    reconstructedFileUrl += "/"
+    reconstructedFileUrl += "/";
   }
-}
+};

package/src/grantPermissionsOnEntry.js

@@ -1,20 +1,20 @@
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
-import { readEntryPermissions } from "./readEntryPermissions.js"
-import { writeEntryPermissions } from "./writeEntryPermissions.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { readEntryPermissions } from "./readEntryPermissions.js";
+import { writeEntryPermissions } from "./writeEntryPermissions.js";
 
 export const grantPermissionsOnEntry = async (
   source,
   { read = false, write = false, execute = false },
 ) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source)
+  const sourceUrl = assertAndNormalizeFileUrl(source);
 
-  const filePermissions = await readEntryPermissions(sourceUrl)
+  const filePermissions = await readEntryPermissions(sourceUrl);
   await writeEntryPermissions(sourceUrl, {
     owner: { read, write, execute },
     group: { read, write, execute },
     others: { read, write, execute },
-  })
+  });
   return async () => {
-    await writeEntryPermissions(sourceUrl, filePermissions)
-  }
-}
+    await writeEntryPermissions(sourceUrl, filePermissions);
+  };
+};

package/src/internal/createWatcher.js

@@ -1,29 +1,29 @@
-import { watch, openSync, closeSync } from "node:fs"
+import { watch, openSync, closeSync } from "node:fs";
 
-const isWindows = process.platform === "win32"
+const isWindows = process.platform === "win32";
 
 export const createWatcher = (sourcePath, options) => {
-  const watcher = watch(sourcePath, options)
+  const watcher = watch(sourcePath, options);
 
   if (isWindows) {
     watcher.on("error", async (error) => {
       // https://github.com/joyent/node/issues/4337
       if (error.code === "EPERM") {
         try {
-          const fd = openSync(sourcePath, "r")
-          closeSync(fd)
+          const fd = openSync(sourcePath, "r");
+          closeSync(fd);
         } catch (e) {
           if (e.code === "ENOENT") {
-            return
+            return;
           }
-          console.error(`error while fixing windows eperm: ${e.stack}`)
-          throw error
+          console.error(`error while fixing windows eperm: ${e.stack}`);
+          throw error;
         }
       } else {
-        throw error
+        throw error;
       }
-    })
+    });
   }
 
-  return watcher
-}
+  return watcher;
+};

package/src/internal/getCommandArgument.js

@@ -1,15 +1,15 @@
 export const getCommandArgument = (argv, name) => {
-  let i = 0
+  let i = 0;
 
   while (i < argv.length) {
-    const arg = argv[i]
+    const arg = argv[i];
 
     if (arg === name) {
       return {
         name,
         index: i,
         value: "",
-      }
+      };
     }
 
     if (arg.startsWith(`${name}=`)) {
@@ -17,11 +17,11 @@ export const getCommandArgument = (argv, name) => {
         name,
         index: i,
         value: arg.slice(`${name}=`.length),
-      }
+      };
     }
 
-    i++
+    i++;
   }
 
-  return null
-}
+  return null;
+};

package/src/internal/guard_second_call.js

@@ -2,38 +2,38 @@ export const guardTooFastSecondCall = (
   callback,
   cooldownBetweenFileEvents = 40,
 ) => {
-  let previousCallMs
+  let previousCallMs;
   return (...args) => {
-    const nowMs = Date.now()
+    const nowMs = Date.now();
     if (previousCallMs) {
-      const msEllapsed = nowMs - previousCallMs
+      const msEllapsed = nowMs - previousCallMs;
       if (msEllapsed < cooldownBetweenFileEvents) {
-        previousCallMs = null
-        return
+        previousCallMs = null;
+        return;
       }
     }
-    previousCallMs = nowMs
-    callback(...args)
-  }
-}
+    previousCallMs = nowMs;
+    callback(...args);
+  };
+};
 
 export const guardTooFastSecondCallPerFile = (
   callback,
   cooldownBetweenFileEvents = 40,
 ) => {
-  const previousCallMsMap = new Map()
+  const previousCallMsMap = new Map();
   return (fileEvent) => {
-    const { relativeUrl } = fileEvent
-    const previousCallMs = previousCallMsMap.get(relativeUrl)
-    const nowMs = Date.now()
+    const { relativeUrl } = fileEvent;
+    const previousCallMs = previousCallMsMap.get(relativeUrl);
+    const nowMs = Date.now();
     if (previousCallMs) {
-      const msEllapsed = nowMs - previousCallMs
+      const msEllapsed = nowMs - previousCallMs;
       if (msEllapsed < cooldownBetweenFileEvents) {
-        previousCallMsMap.delete(relativeUrl)
-        return
+        previousCallMsMap.delete(relativeUrl);
+        return;
       }
     }
-    previousCallMsMap.set(relativeUrl, nowMs)
-    callback(fileEvent)
-  }
-}
+    previousCallMsMap.set(relativeUrl, nowMs);
+    callback(fileEvent);
+  };
+};

package/src/internal/permissions.js

@@ -3,15 +3,15 @@
 // https://github.com/TooTallNate/stat-mode
 
 // cannot get from fs.constants because they are not available on windows
-const S_IRUSR = 256 /* 0000400 read permission, owner */
-const S_IWUSR = 128 /* 0000200 write permission, owner */
-const S_IXUSR = 64 /* 0000100 execute/search permission, owner */
-const S_IRGRP = 32 /* 0000040 read permission, group */
-const S_IWGRP = 16 /* 0000020 write permission, group */
-const S_IXGRP = 8 /* 0000010 execute/search permission, group */
-const S_IROTH = 4 /* 0000004 read permission, others */
-const S_IWOTH = 2 /* 0000002 write permission, others */
-const S_IXOTH = 1 /* 0000001 execute/search permission, others */
+const S_IRUSR = 256; /* 0000400 read permission, owner */
+const S_IWUSR = 128; /* 0000200 write permission, owner */
+const S_IXUSR = 64; /* 0000100 execute/search permission, owner */
+const S_IRGRP = 32; /* 0000040 read permission, group */
+const S_IWGRP = 16; /* 0000020 write permission, group */
+const S_IXGRP = 8; /* 0000010 execute/search permission, group */
+const S_IROTH = 4; /* 0000004 read permission, others */
+const S_IWOTH = 2; /* 0000002 write permission, others */
+const S_IXOTH = 1; /* 0000001 execute/search permission, others */
 
 /*
 here we could warn that on windows only 0o444 or 0o666 will work
@@ -35,41 +35,41 @@ export const binaryFlagsToPermissions = (binaryFlags) => {
     read: Boolean(binaryFlags & S_IRUSR),
     write: Boolean(binaryFlags & S_IWUSR),
     execute: Boolean(binaryFlags & S_IXUSR),
-  }
+  };
 
   const group = {
     read: Boolean(binaryFlags & S_IRGRP),
     write: Boolean(binaryFlags & S_IWGRP),
     execute: Boolean(binaryFlags & S_IXGRP),
-  }
+  };
 
   const others = {
     read: Boolean(binaryFlags & S_IROTH),
     write: Boolean(binaryFlags & S_IWOTH),
     execute: Boolean(binaryFlags & S_IXOTH),
-  }
+  };
 
   return {
     owner,
     group,
     others,
-  }
-}
+  };
+};
 
 export const permissionsToBinaryFlags = ({ owner, group, others }) => {
-  let binaryFlags = 0
+  let binaryFlags = 0;
 
-  if (owner.read) binaryFlags |= S_IRUSR
-  if (owner.write) binaryFlags |= S_IWUSR
-  if (owner.execute) binaryFlags |= S_IXUSR
+  if (owner.read) binaryFlags |= S_IRUSR;
+  if (owner.write) binaryFlags |= S_IWUSR;
+  if (owner.execute) binaryFlags |= S_IXUSR;
 
-  if (group.read) binaryFlags |= S_IRGRP
-  if (group.write) binaryFlags |= S_IWGRP
-  if (group.execute) binaryFlags |= S_IXGRP
+  if (group.read) binaryFlags |= S_IRGRP;
+  if (group.write) binaryFlags |= S_IWGRP;
+  if (group.execute) binaryFlags |= S_IXGRP;
 
-  if (others.read) binaryFlags |= S_IROTH
-  if (others.write) binaryFlags |= S_IWOTH
-  if (others.execute) binaryFlags |= S_IXOTH
+  if (others.read) binaryFlags |= S_IROTH;
+  if (others.write) binaryFlags |= S_IWOTH;
+  if (others.execute) binaryFlags |= S_IXOTH;
 
-  return binaryFlags
-}
+  return binaryFlags;
+};

package/src/internal/read_entry_info.js

@@ -1,20 +1,20 @@
-import { statSync } from "node:fs"
+import { statSync } from "node:fs";
 
-import { statsToType } from "./statsToType.js"
+import { statsToType } from "./statsToType.js";
 
 export const readEntryInfo = (url) => {
   try {
-    const stats = statSync(new URL(url))
-    const type = statsToType(stats)
+    const stats = statSync(new URL(url));
+    const type = statsToType(stats);
     return {
       type,
       atimeMs: stats.atimeMs,
       mtimeMs: stats.mtimeMs,
-    }
+    };
   } catch (e) {
     if (e.code === "ENOENT") {
-      return null
+      return null;
     }
-    throw e
+    throw e;
   }
-}
+};

package/src/internal/statsToType.js

@@ -1,10 +1,10 @@
 export const statsToType = (stats) => {
-  if (stats.isFile()) return "file"
-  if (stats.isDirectory()) return "directory"
-  if (stats.isSymbolicLink()) return "symbolic-link"
-  if (stats.isFIFO()) return "fifo"
-  if (stats.isSocket()) return "socket"
-  if (stats.isCharacterDevice()) return "character-device"
-  if (stats.isBlockDevice()) return "block-device"
-  return undefined
-}
+  if (stats.isFile()) return "file";
+  if (stats.isDirectory()) return "directory";
+  if (stats.isSymbolicLink()) return "symbolic-link";
+  if (stats.isFIFO()) return "fifo";
+  if (stats.isSocket()) return "socket";
+  if (stats.isCharacterDevice()) return "character-device";
+  if (stats.isBlockDevice()) return "block-device";
+  return undefined;
+};

package/src/internal/track_resources.js

@@ -1,21 +1,21 @@
 export const trackResources = () => {
-  const callbackArray = []
+  const callbackArray = [];
 
   const registerCleanupCallback = (callback) => {
     if (typeof callback !== "function")
       throw new TypeError(`callback must be a function
-callback: ${callback}`)
-    callbackArray.push(callback)
+callback: ${callback}`);
+    callbackArray.push(callback);
     return () => {
-      const index = callbackArray.indexOf(callback)
-      if (index > -1) callbackArray.splice(index, 1)
-    }
-  }
+      const index = callbackArray.indexOf(callback);
+      if (index > -1) callbackArray.splice(index, 1);
+    };
+  };
 
   const cleanup = async (reason) => {
-    const localCallbackArray = callbackArray.slice()
-    await Promise.all(localCallbackArray.map((callback) => callback(reason)))
-  }
+    const localCallbackArray = callbackArray.slice();
+    await Promise.all(localCallbackArray.map((callback) => callback(reason)));
+  };
 
-  return { registerCleanupCallback, cleanup }
-}
+  return { registerCleanupCallback, cleanup };
+};

package/src/internal/urlTargetsSameFileSystemPath.js

@@ -1,5 +1,5 @@
 export const urlTargetsSameFileSystemPath = (leftUrl, rightUrl) => {
-  if (leftUrl.endsWith("/")) leftUrl = leftUrl.slice(0, -1)
-  if (rightUrl.endsWith("/")) rightUrl = rightUrl.slice(0, -1)
-  return leftUrl === rightUrl
-}
+  if (leftUrl.endsWith("/")) leftUrl = leftUrl.slice(0, -1);
+  if (rightUrl.endsWith("/")) rightUrl = rightUrl.slice(0, -1);
+  return leftUrl === rightUrl;
+};

package/src/listFilesMatching.js

@@ -1,4 +1,4 @@
-import { collectFiles } from "./collectFiles.js"
+import { collectFiles } from "./collectFiles.js";
 
 export const listFilesMatching = async ({
   directoryUrl = process.cwd(),
@@ -6,13 +6,13 @@ export const listFilesMatching = async ({
   signal,
 }) => {
   if (typeof patterns !== "object" || patterns === null) {
-    throw new TypeError(`patterns must be an object, got ${patterns}`)
+    throw new TypeError(`patterns must be an object, got ${patterns}`);
   }
   const fileDatas = await collectFiles({
     signal,
     directoryUrl,
     associations: { matches: patterns },
     predicate: ({ matches }) => matches,
-  })
-  return fileDatas.map(({ url }) => url)
-}
+  });
+  return fileDatas.map(({ url }) => url);
+};

package/src/main.js

@@ -1,41 +1,41 @@
 export {
   validateDirectoryUrl,
   assertAndNormalizeDirectoryUrl,
-} from "./directory_url_validation.js"
+} from "./directory_url_validation.js";
 export {
   validateFileUrl,
   assertAndNormalizeFileUrl,
-} from "./file_url_validation.js"
-export { assertDirectoryPresence } from "./assertDirectoryPresence.js"
-export { assertFilePresence } from "./assertFilePresence.js"
-export { bufferToEtag } from "./bufferToEtag.js"
-export { collectDirectoryMatchReport } from "./collectDirectoryMatchReport.js"
-export { collectFiles } from "./collectFiles.js"
-export { comparePathnames } from "./comparePathnames.js"
-export { ensureEmptyDirectory } from "./ensureEmptyDirectory.js"
-export { ensureParentDirectories } from "./ensureParentDirectories.js"
-export { ensureWindowsDriveLetter } from "./ensureWindowsDriveLetter.js"
-export { copyEntry } from "./copyEntry.js"
-export { copyDirectoryContent } from "./copyDirectoryContent.js"
-export { getRealFileSystemUrlSync } from "./getRealFileSystemUrlSync.js"
-export { grantPermissionsOnEntry } from "./grantPermissionsOnEntry.js"
-export { listFilesMatching } from "./listFilesMatching.js"
-export { moveDirectoryContent } from "./moveDirectoryContent.js"
-export { moveEntry } from "./moveEntry.js"
-export { readDirectory } from "./readDirectory.js"
-export { readFile } from "./readFile.js"
-export { readFileSync } from "./readFileSync.js"
-export { readEntryModificationTime } from "./readEntryModificationTime.js"
-export { readEntryPermissions } from "./readEntryPermissions.js"
-export { readEntryStat } from "./readEntryStat.js"
-export { readSymbolicLink } from "./readSymbolicLink.js"
-export { registerDirectoryLifecycle } from "./registerDirectoryLifecycle.js"
-export { registerFileLifecycle } from "./registerFileLifecycle.js"
-export { removeEntry } from "./removeEntry.js"
-export { testEntryPermissions } from "./testEntryPermissions.js"
-export { writeDirectory } from "./writeDirectory.js"
-export { writeFile } from "./writeFile.js"
-export { writeFileSync } from "./writeFileSync.js"
-export { writeEntryModificationTime } from "./writeEntryModificationTime.js"
-export { writeEntryPermissions } from "./writeEntryPermissions.js"
-export { writeSymbolicLink } from "./writeSymbolicLink.js"
+} from "./file_url_validation.js";
+export { assertDirectoryPresence } from "./assertDirectoryPresence.js";
+export { assertFilePresence } from "./assertFilePresence.js";
+export { bufferToEtag } from "./bufferToEtag.js";
+export { collectDirectoryMatchReport } from "./collectDirectoryMatchReport.js";
+export { collectFiles } from "./collectFiles.js";
+export { comparePathnames } from "./comparePathnames.js";
+export { ensureEmptyDirectory } from "./ensureEmptyDirectory.js";
+export { ensureParentDirectories } from "./ensureParentDirectories.js";
+export { ensureWindowsDriveLetter } from "./ensureWindowsDriveLetter.js";
+export { copyEntry } from "./copyEntry.js";
+export { copyDirectoryContent } from "./copyDirectoryContent.js";
+export { getRealFileSystemUrlSync } from "./getRealFileSystemUrlSync.js";
+export { grantPermissionsOnEntry } from "./grantPermissionsOnEntry.js";
+export { listFilesMatching } from "./listFilesMatching.js";
+export { moveDirectoryContent } from "./moveDirectoryContent.js";
+export { moveEntry } from "./moveEntry.js";
+export { readDirectory } from "./readDirectory.js";
+export { readFile } from "./readFile.js";
+export { readFileSync } from "./readFileSync.js";
+export { readEntryModificationTime } from "./readEntryModificationTime.js";
+export { readEntryPermissions } from "./readEntryPermissions.js";
+export { readEntryStat } from "./readEntryStat.js";
+export { readSymbolicLink } from "./readSymbolicLink.js";
+export { registerDirectoryLifecycle } from "./registerDirectoryLifecycle.js";
+export { registerFileLifecycle } from "./registerFileLifecycle.js";
+export { removeEntry } from "./removeEntry.js";
+export { testEntryPermissions } from "./testEntryPermissions.js";
+export { writeDirectory } from "./writeDirectory.js";
+export { writeFile } from "./writeFile.js";
+export { writeFileSync } from "./writeFileSync.js";
+export { writeEntryModificationTime } from "./writeEntryModificationTime.js";
+export { writeEntryPermissions } from "./writeEntryPermissions.js";
+export { writeSymbolicLink } from "./writeSymbolicLink.js";