@jsenv/filesystem 2.7.1 → 3.1.0

package/main.js

@@ -1,5 +1,3 @@
-/* eslint-disable import/max-dependencies */
-
 // we won't internalize @jsenv/url-meta
 // so that @jsenv/url-meta does not becomes nodejs specific
 // but these functions could be inside this repository
@@ -21,28 +19,31 @@ export { comparePathnames } from "./src/comparePathnames.js"
 export { ensureEmptyDirectory } from "./src/ensureEmptyDirectory.js"
 export { ensureParentDirectories } from "./src/ensureParentDirectories.js"
 export { ensureWindowsDriveLetter } from "./src/ensureWindowsDriveLetter.js"
-export { copyFileSystemNode } from "./src/copyFileSystemNode.js"
+export { copyEntry } from "./src/copyEntry.js"
 export { copyDirectoryContent } from "./src/copyDirectoryContent.js"
 export { fileSystemPathToUrl } from "./src/fileSystemPathToUrl.js"
+export { fileSystemRootUrl } from "./src/fileSystemRootUrl.js"
 export { getRealFileSystemUrlSync } from "./src/getRealFileSystemUrlSync.js"
-export { grantPermissionsOnFileSystemNode } from "./src/grantPermissionsOnFileSystemNode.js"
+export { grantPermissionsOnEntry } from "./src/grantPermissionsOnEntry.js"
 export { isFileSystemPath } from "./src/isFileSystemPath.js"
 export { listFilesMatching } from "./src/listFilesMatching.js"
 export { memoize } from "./src/memoize.js"
 export { moveDirectoryContent } from "./src/moveDirectoryContent.js"
-export { moveFileSystemNode } from "./src/moveFileSystemNode.js"
+export { moveEntry } from "./src/moveEntry.js"
+export { moveUrl } from "./src/moveUrl.js"
 export { readDirectory } from "./src/readDirectory.js"
 export { readFile } from "./src/readFile.js"
-export { readFileSystemNodeModificationTime } from "./src/readFileSystemNodeModificationTime.js"
-export { readFileSystemNodePermissions } from "./src/readFileSystemNodePermissions.js"
-export { readFileSystemNodeStat } from "./src/readFileSystemNodeStat.js"
+export { readFileSync } from "./src/readFileSync.js"
+export { readEntryModificationTime } from "./src/readEntryModificationTime.js"
+export { readEntryPermissions } from "./src/readEntryPermissions.js"
+export { readEntryStat } from "./src/readEntryStat.js"
 export { readSymbolicLink } from "./src/readSymbolicLink.js"
 export { registerDirectoryLifecycle } from "./src/registerDirectoryLifecycle.js"
 export { registerFileLifecycle } from "./src/registerFileLifecycle.js"
-export { removeFileSystemNode } from "./src/removeFileSystemNode.js"
+export { removeEntry } from "./src/removeEntry.js"
 export { resolveDirectoryUrl } from "./src/resolveDirectoryUrl.js"
 export { resolveUrl } from "./src/resolveUrl.js"
-export { testFileSystemNodePermissions } from "./src/testFileSystemNodePermissions.js"
+export { testEntryPermissions } from "./src/testEntryPermissions.js"
 export { urlIsInsideOf } from "./src/urlIsInsideOf.js"
 export { urlToBasename } from "./src/urlToBasename.js"
 export { urlToExtension } from "./src/urlToExtension.js"
@@ -56,6 +57,7 @@ export { urlToRessource } from "./src/urlToRessource.js"
 export { urlToScheme } from "./src/urlToScheme.js"
 export { writeDirectory } from "./src/writeDirectory.js"
 export { writeFile } from "./src/writeFile.js"
-export { writeFileSystemNodeModificationTime } from "./src/writeFileSystemNodeModificationTime.js"
-export { writeFileSystemNodePermissions } from "./src/writeFileSystemNodePermissions.js"
+export { writeFileSync } from "./src/writeFileSync.js"
+export { writeEntryModificationTime } from "./src/writeEntryModificationTime.js"
+export { writeEntryPermissions } from "./src/writeEntryPermissions.js"
 export { writeSymbolicLink } from "./src/writeSymbolicLink.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/filesystem",
-  "version": "2.7.1",
+  "version": "3.1.0",
   "description": "Collection of functions to interact with filesystem in Node.js",
   "license": "MIT",
   "author": {

package/src/assertDirectoryPresence.js

@@ -1,13 +1,13 @@
 import { statsToType } from "./internal/statsToType.js"
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
-import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
+import { readEntryStat } from "./readEntryStat.js"
 
 export const assertDirectoryPresence = async (source) => {
   const sourceUrl = assertAndNormalizeFileUrl(source)
   const sourcePath = urlToFileSystemPath(sourceUrl)
 
-  const sourceStats = await readFileSystemNodeStat(sourceUrl, {
+  const sourceStats = await readEntryStat(sourceUrl, {
     nullIfNotFound: true,
   })
   if (!sourceStats) {

package/src/assertFilePresence.js

@@ -1,13 +1,13 @@
 import { statsToType } from "./internal/statsToType.js"
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
-import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
+import { readEntryStat } from "./readEntryStat.js"
 
 export const assertFilePresence = async (source) => {
   const sourceUrl = assertAndNormalizeFileUrl(source)
   const sourcePath = urlToFileSystemPath(sourceUrl)
 
-  const sourceStats = await readFileSystemNodeStat(sourceUrl, {
+  const sourceStats = await readEntryStat(sourceUrl, {
     nullIfNotFound: true,
   })
   if (!sourceStats) {

package/src/collectDirectoryMatchReport.js

@@ -8,7 +8,7 @@ import {
 import { ensureUrlTrailingSlash } from "./internal/ensureUrlTrailingSlash.js"
 import { assertAndNormalizeDirectoryUrl } from "./assertAndNormalizeDirectoryUrl.js"
 import { readDirectory } from "./readDirectory.js"
-import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
+import { readEntryStat } from "./readEntryStat.js"
 import { urlToRelativeUrl } from "./urlToRelativeUrl.js"
 import { comparePathnames } from "./comparePathnames.js"
 
@@ -46,7 +46,7 @@ export const collectDirectoryMatchReport = async ({
         )
 
         collectOperation.throwIfAborted()
-        const directoryChildNodeStats = await readFileSystemNodeStat(
+        const directoryChildNodeStats = await readEntryStat(
           directoryChildNodeUrl,
           {
             // we ignore symlink because recursively traversed

package/src/collectFiles.js

@@ -7,7 +7,7 @@ import {
 
 import { assertAndNormalizeDirectoryUrl } from "./assertAndNormalizeDirectoryUrl.js"
 import { readDirectory } from "./readDirectory.js"
-import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
+import { readEntryStat } from "./readEntryStat.js"
 import { urlToRelativeUrl } from "./urlToRelativeUrl.js"
 import { comparePathnames } from "./comparePathnames.js"
 
@@ -39,7 +39,7 @@ export const collectFiles = async ({
         const directoryChildNodeUrl = `${directoryUrl}${directoryItem}`
 
         collectOperation.throwIfAborted()
-        const directoryChildNodeStats = await readFileSystemNodeStat(
+        const directoryChildNodeStats = await readEntryStat(
           directoryChildNodeUrl,
           {
             // we ignore symlink because recursively traversed

package/src/copyDirectoryContent.js

@@ -1,12 +1,12 @@
 import { Abort } from "@jsenv/abort"
 
 import { assertAndNormalizeDirectoryUrl } from "./assertAndNormalizeDirectoryUrl.js"
-import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
+import { readEntryStat } from "./readEntryStat.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 import { readSymbolicLink } from "./readSymbolicLink.js"
 import { resolveUrl } from "./resolveUrl.js"
 import { readDirectory } from "./readDirectory.js"
-import { copyFileSystemNode } from "./copyFileSystemNode.js"
+import { copyEntry } from "./copyEntry.js"
 import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js"
 import { statsToType } from "./internal/statsToType.js"
 
@@ -22,7 +22,7 @@ export const copyDirectoryContent = async ({
   let toUrl = assertAndNormalizeDirectoryUrl(to)
   let toPath = urlToFileSystemPath(toUrl)
 
-  const sourceStats = await readFileSystemNodeStat(fromUrl, {
+  const sourceStats = await readEntryStat(fromUrl, {
     nullIfNotFound: true,
     followLink: false,
   })
@@ -36,7 +36,7 @@ export const copyDirectoryContent = async ({
     )
   }
 
-  let destinationStats = await readFileSystemNodeStat(toUrl, {
+  let destinationStats = await readEntryStat(toUrl, {
     nullIfNotFound: true,
     // 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..
@@ -46,7 +46,7 @@ export const copyDirectoryContent = async ({
     const linkTarget = await readSymbolicLink(toUrl)
     toUrl = resolveUrl(linkTarget, toUrl)
     toPath = urlToFileSystemPath(toUrl)
-    destinationStats = await readFileSystemNodeStat(toUrl, {
+    destinationStats = await readEntryStat(toUrl, {
       nullIfNotFound: true,
     })
   }
@@ -77,7 +77,7 @@ export const copyDirectoryContent = async ({
         const from = resolveUrl(directoryEntry, fromUrl)
         const to = resolveUrl(directoryEntry, toUrl)
         await copyOperation.withSignal(async (signal) => {
-          await copyFileSystemNode({
+          await copyEntry({
             signal,
             from,
             to,

package/src/{copyFileSystemNode.js → copyEntry.js}

@@ -9,18 +9,18 @@ import { binaryFlagsToPermissions } from "./internal/permissions.js"
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
 import { writeDirectory } from "./writeDirectory.js"
 import { urlToRelativeUrl } from "./urlToRelativeUrl.js"
-import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
+import { readEntryStat } from "./readEntryStat.js"
 import { ensureParentDirectories } from "./ensureParentDirectories.js"
-import { writeFileSystemNodePermissions } from "./writeFileSystemNodePermissions.js"
-import { writeFileSystemNodeModificationTime } from "./writeFileSystemNodeModificationTime.js"
+import { writeEntryPermissions } from "./writeEntryPermissions.js"
+import { writeEntryModificationTime } from "./writeEntryModificationTime.js"
 import { readDirectory } from "./readDirectory.js"
 import { readSymbolicLink } from "./readSymbolicLink.js"
 import { writeSymbolicLink } from "./writeSymbolicLink.js"
 import { urlIsInsideOf } from "./urlIsInsideOf.js"
-import { removeFileSystemNode } from "./removeFileSystemNode.js"
+import { removeEntry } from "./removeEntry.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 
-export const copyFileSystemNode = async ({
+export const copyEntry = async ({
   signal = new AbortController().signal,
   from,
   to,
@@ -36,7 +36,7 @@ export const copyFileSystemNode = async ({
   let toUrl = assertAndNormalizeFileUrl(to)
   let toPath = urlToFileSystemPath(toUrl)
 
-  const sourceStats = await readFileSystemNodeStat(fromUrl, {
+  const sourceStats = await readEntryStat(fromUrl, {
     nullIfNotFound: true,
     followLink: false,
   })
@@ -44,7 +44,7 @@ export const copyFileSystemNode = async ({
     throw new Error(`nothing to copy at ${fromPath}`)
   }
 
-  let destinationStats = await readFileSystemNodeStat(toUrl, {
+  let destinationStats = await readEntryStat(toUrl, {
     nullIfNotFound: true,
     // 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..
@@ -55,7 +55,7 @@ export const copyFileSystemNode = async ({
     const linkTarget = await readSymbolicLink(toUrl)
     toUrl = resolveUrl(linkTarget, toUrl)
     toPath = urlToFileSystemPath(toUrl)
-    destinationStats = await readFileSystemNodeStat(toUrl, {
+    destinationStats = await readEntryStat(toUrl, {
       nullIfNotFound: true,
     })
   }
@@ -130,7 +130,7 @@ export const copyFileSystemNode = async ({
     // we must guess ourself the type of the symlink
     // because the destination might not exists because not yet copied
     // https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_fs_symlink_target_path_type_callback
-    const targetStats = await readFileSystemNodeStat(symbolicLinkTargetUrl, {
+    const targetStats = await readEntryStat(symbolicLinkTargetUrl, {
       nullIfNotFound: true,
       followLink: false,
     })
@@ -148,13 +148,10 @@ export const copyFileSystemNode = async ({
     if (preservePermissions || preserveMtime) {
       const { mode, mtimeMs } = stats
       if (preservePermissions) {
-        await writeFileSystemNodePermissions(
-          toUrl,
-          binaryFlagsToPermissions(mode),
-        )
+        await writeEntryPermissions(toUrl, binaryFlagsToPermissions(mode))
       }
       if (preserveMtime) {
-        await writeFileSystemNodeModificationTime(toUrl, mtimeMs)
+        await writeEntryModificationTime(toUrl, mtimeMs)
       }
     }
   }
@@ -172,11 +169,11 @@ export const copyFileSystemNode = async ({
     const names = await readDirectory(directoryUrl)
     await Promise.all(
       names.map(async (name) => {
-        const fileSystemNodeUrl = resolveUrl(name, directoryUrl)
-        const stats = await readFileSystemNodeStat(fileSystemNodeUrl, {
+        const entryUrl = resolveUrl(name, directoryUrl)
+        const stats = await readEntryStat(entryUrl, {
           followLink: false,
         })
-        await visit(fileSystemNodeUrl, stats)
+        await visit(entryUrl, stats)
       }),
     )
   }
@@ -198,7 +195,7 @@ export const copyFileSystemNode = async ({
       }
 
       // remove file, link, directory...
-      await removeFileSystemNode(toUrl, {
+      await removeEntry(toUrl, {
         signal: copyOperation.signal,
         recursive: true,
         allowUseless: true,

package/src/ensureEmptyDirectory.js

@@ -2,11 +2,11 @@ import { statsToType } from "./internal/statsToType.js"
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 import { writeDirectory } from "./writeDirectory.js"
-import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
-import { removeFileSystemNode } from "./removeFileSystemNode.js"
+import { readEntryStat } from "./readEntryStat.js"
+import { removeEntry } from "./removeEntry.js"
 
 export const ensureEmptyDirectory = async (source) => {
-  const stats = await readFileSystemNodeStat(source, {
+  const stats = await readEntryStat(source, {
     nullIfNotFound: true,
     followLink: false,
   })
@@ -16,7 +16,7 @@ export const ensureEmptyDirectory = async (source) => {
   }
   if (stats.isDirectory()) {
     // if there is a directory remove its content and done
-    return removeFileSystemNode(source, {
+    return removeEntry(source, {
       allowUseless: true,
       recursive: true,
       onlyContent: true,

package/src/ensureParentDirectories.js

@@ -1,4 +1,5 @@
-import { dirname } from "path"
+import { dirname } from "node:path"
+
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 import { writeDirectory } from "./writeDirectory.js"

package/src/fileSystemRootUrl.js

@@ -0,0 +1,2 @@
+export const fileSystemRootUrl =
+  process.platform === "win32" ? `file///${process.cwd()[0]}:/` : "file:///"

package/src/grantPermissionsOnEntry.js

@@ -0,0 +1,20 @@
+import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.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 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)
+  }
+}

package/src/internal/{fileSystemNodeToTypeOrNull.js → entryToTypeOrNull.js}

@@ -4,7 +4,7 @@ import { urlToFileSystemPath } from "../urlToFileSystemPath.js"
 
 import { statsToType } from "./statsToType.js"
 
-export const fileSystemNodeToTypeOrNull = (url) => {
+export const entryToTypeOrNull = (url) => {
   const path = urlToFileSystemPath(url)
   try {
     const stats = statSync(path)

package/src/internal/getCommonPathname.js

@@ -10,7 +10,6 @@ export const getCommonPathname = (pathname, otherPathname) => {
   }
 
   const commonString = pathname.slice(0, firstDifferentCharacterIndex + 1)
-
   // the first different char is at firstDifferentCharacterIndex
   if (pathname.charAt(firstDifferentCharacterIndex) === "/") {
     return commonString

package/src/moveDirectoryContent.js

@@ -1,12 +1,12 @@
 import { Abort } from "@jsenv/abort"
 
 import { assertAndNormalizeDirectoryUrl } from "./assertAndNormalizeDirectoryUrl.js"
-import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
+import { readEntryStat } from "./readEntryStat.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 import { readSymbolicLink } from "./readSymbolicLink.js"
 import { resolveUrl } from "./resolveUrl.js"
 import { readDirectory } from "./readDirectory.js"
-import { moveFileSystemNode } from "./moveFileSystemNode.js"
+import { moveEntry } from "./moveEntry.js"
 import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js"
 import { statsToType } from "./internal/statsToType.js"
 
@@ -22,7 +22,7 @@ export const moveDirectoryContent = async ({
   let toUrl = assertAndNormalizeDirectoryUrl(to)
   let toPath = urlToFileSystemPath(toUrl)
 
-  const sourceStats = await readFileSystemNodeStat(fromUrl, {
+  const sourceStats = await readEntryStat(fromUrl, {
     nullIfNotFound: true,
     followLink: false,
   })
@@ -36,7 +36,7 @@ export const moveDirectoryContent = async ({
     )
   }
 
-  let destinationStats = await readFileSystemNodeStat(toUrl, {
+  let destinationStats = await readEntryStat(toUrl, {
     nullIfNotFound: true,
     // 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..
@@ -46,7 +46,7 @@ export const moveDirectoryContent = async ({
     const linkTarget = await readSymbolicLink(toUrl)
     toUrl = resolveUrl(linkTarget, toUrl)
     toPath = urlToFileSystemPath(toUrl)
-    destinationStats = await readFileSystemNodeStat(toUrl, {
+    destinationStats = await readEntryStat(toUrl, {
       nullIfNotFound: true,
     })
   }
@@ -78,7 +78,7 @@ export const moveDirectoryContent = async ({
         const to = resolveUrl(directoryEntry, toUrl)
 
         await moveOperation.withSignal(async (signal) => {
-          await moveFileSystemNode({
+          await moveEntry({
             signal,
             from,
             to,

package/src/{moveFileSystemNode.js → moveEntry.js}

@@ -7,12 +7,12 @@ import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 import { resolveUrl } from "./resolveUrl.js"
 import { ensureParentDirectories } from "./ensureParentDirectories.js"
-import { removeFileSystemNode } from "./removeFileSystemNode.js"
-import { copyFileSystemNode } from "./copyFileSystemNode.js"
-import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
+import { removeEntry } from "./removeEntry.js"
+import { copyEntry } from "./copyEntry.js"
+import { readEntryStat } from "./readEntryStat.js"
 import { readSymbolicLink } from "./readSymbolicLink.js"
 
-export const moveFileSystemNode = async ({
+export const moveEntry = async ({
   signal = new AbortController().signal,
   from,
   to,
@@ -25,7 +25,7 @@ export const moveFileSystemNode = async ({
   let toUrl = assertAndNormalizeFileUrl(to)
   let toPath = urlToFileSystemPath(toUrl)
 
-  const sourceStats = await readFileSystemNodeStat(fromUrl, {
+  const sourceStats = await readEntryStat(fromUrl, {
     nullIfNotFound: true,
     followLink: false,
   })
@@ -33,7 +33,7 @@ export const moveFileSystemNode = async ({
     throw new Error(`nothing to move from ${fromPath}`)
   }
 
-  let destinationStats = await readFileSystemNodeStat(toUrl, {
+  let destinationStats = await readEntryStat(toUrl, {
     nullIfNotFound: true,
     // 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..
@@ -44,7 +44,7 @@ export const moveFileSystemNode = async ({
     const linkTarget = await readSymbolicLink(toUrl)
     toUrl = resolveUrl(linkTarget, toUrl)
     toPath = urlToFileSystemPath(toUrl)
-    destinationStats = await readFileSystemNodeStat(toUrl, {
+    destinationStats = await readEntryStat(toUrl, {
       nullIfNotFound: true,
     })
   }
@@ -78,7 +78,7 @@ export const moveFileSystemNode = async ({
       }
 
       // remove file, link, directory...
-      await removeFileSystemNode(toUrl, {
+      await removeEntry(toUrl, {
         signal: moveOperation.signal,
         recursive: true,
       })
@@ -89,12 +89,12 @@ export const moveFileSystemNode = async ({
     moveOperation.throwIfAborted()
     await moveNaive(fromPath, toPath, {
       handleCrossDeviceError: async () => {
-        await copyFileSystemNode({
+        await copyEntry({
           from: fromUrl,
           to: toUrl,
           preserveStat: true,
         })
-        await removeFileSystemNode(fromUrl, {
+        await removeEntry(fromUrl, {
           signal: moveOperation.signal,
           recursive: true,
         })

package/src/moveUrl.js

@@ -0,0 +1,10 @@
+import { urlToRelativeUrl } from "./urlToRelativeUrl.js"
+
+export const moveUrl = ({ url, from, to, preferAbsolute = false }) => {
+  const relativeUrl = urlToRelativeUrl(url, from)
+  const absoluteUrl = new URL(relativeUrl, to).href
+  if (preferAbsolute) {
+    return absoluteUrl
+  }
+  return urlToRelativeUrl(absoluteUrl, to)
+}

package/src/readEntryModificationTime.js

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

package/src/{readFileSystemNodePermissions.js → readEntryPermissions.js}

@@ -11,7 +11,7 @@ import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 
 const { stat } = promises
 
-export const readFileSystemNodePermissions = async (source) => {
+export const readEntryPermissions = async (source) => {
   const sourceUrl = assertAndNormalizeFileUrl(source)
   const sourcePath = urlToFileSystemPath(sourceUrl)
 

package/src/{readFileSystemNodeStat.js → readEntryStat.js}

@@ -7,11 +7,11 @@ import { lstat, stat } from "node:fs"
 
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
-import { writeFileSystemNodePermissions } from "./writeFileSystemNodePermissions.js"
+import { writeEntryPermissions } from "./writeEntryPermissions.js"
 
 const isWindows = process.platform === "win32"
 
-export const readFileSystemNodeStat = async (
+export const readEntryStat = async (
   source,
   { nullIfNotFound = false, followLink = true } = {},
 ) => {
@@ -41,7 +41,7 @@ export const readFileSystemNodeStat = async (
               // 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 writeFileSystemNodePermissions(sourceUrl, 0o666)
+              await writeEntryPermissions(sourceUrl, 0o666)
               const stats = await readStat(sourcePath, {
                 followLink,
                 ...handleNotFoundOption,

package/src/readFile.js

@@ -1,13 +1,12 @@
-import { promisify } from "util"
-import { readFile as readFileNode } from "fs"
+import { promisify } from "node:util"
+import { readFile as readFileNode } from "node:fs"
+
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
-import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 
 const readFilePromisified = promisify(readFileNode)
-export const readFile = async (value, { as = "string" } = {}) => {
+export const readFile = async (value, { as = "buffer" } = {}) => {
   const fileUrl = assertAndNormalizeFileUrl(value)
-  const filePath = urlToFileSystemPath(fileUrl)
-  const buffer = await readFilePromisified(filePath)
+  const buffer = await readFilePromisified(new URL(fileUrl))
   if (as === "buffer") {
     return buffer
   }
@@ -17,5 +16,7 @@ export const readFile = async (value, { as = "string" } = {}) => {
   if (as === "json") {
     return JSON.parse(buffer.toString())
   }
-  throw new Error(`as must be one of buffer,string,json, received ${as}.`)
+  throw new Error(
+    `"as" must be one of "buffer","string","json" received "${as}"`,
+  )
 }

package/src/readFileSync.js

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

package/src/registerDirectoryLifecycle.js

@@ -6,7 +6,7 @@ import {
   urlToMeta,
 } from "@jsenv/url-meta"
 import { replaceBackSlashesWithSlashes } from "./internal/replaceBackSlashesWithSlashes.js"
-import { fileSystemNodeToTypeOrNull } from "./internal/fileSystemNodeToTypeOrNull.js"
+import { entryToTypeOrNull } from "./internal/entryToTypeOrNull.js"
 import { createWatcher } from "./internal/createWatcher.js"
 import { trackRessources } from "./internal/trackRessources.js"
 import { ensureUrlTrailingSlash } from "./internal/ensureUrlTrailingSlash.js"
@@ -120,7 +120,7 @@ export const registerDirectoryLifecycle = (
       const removedEntryRelativeUrl = relativeUrlCandidateArray.find(
         (relativeUrlCandidate) => {
           const entryUrl = resolveUrl(relativeUrlCandidate, sourceUrl)
-          const type = fileSystemNodeToTypeOrNull(entryUrl)
+          const type = entryToTypeOrNull(entryUrl)
           return type === null
         },
       )
@@ -137,7 +137,7 @@ export const registerDirectoryLifecycle = (
   const handleChange = (relativeUrl) => {
     const entryUrl = resolveUrl(relativeUrl, sourceUrl)
     const previousType = contentMap.get(relativeUrl)
-    const type = fileSystemNodeToTypeOrNull(entryUrl)
+    const type = entryToTypeOrNull(entryUrl)
 
     if (!entryShouldBeWatched({ relativeUrl, type })) {
       return
@@ -277,7 +277,7 @@ const visitDirectory = ({ directoryUrl, entryFound }) => {
   const directoryPath = urlToFileSystemPath(directoryUrl)
   readdirSync(directoryPath).forEach((entry) => {
     const entryUrl = resolveUrl(entry, directoryUrl)
-    const type = fileSystemNodeToTypeOrNull(entryUrl)
+    const type = entryToTypeOrNull(entryUrl)
     if (type === null) {
       return
     }

package/src/registerFileLifecycle.js

@@ -1,5 +1,5 @@
 import { dirname, basename } from "path"
-import { fileSystemNodeToTypeOrNull } from "./internal/fileSystemNodeToTypeOrNull.js"
+import { entryToTypeOrNull } from "./internal/entryToTypeOrNull.js"
 import { createWatcher } from "./internal/createWatcher.js"
 import { trackRessources } from "./internal/trackRessources.js"
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
@@ -67,7 +67,7 @@ export const registerFileLifecycle = (
     )
   }
 
-  const sourceType = fileSystemNodeToTypeOrNull(sourceUrl)
+  const sourceType = entryToTypeOrNull(sourceUrl)
   if (sourceType === null) {
     if (added) {
       watchFileAdded()
@@ -102,7 +102,7 @@ const watchFileCreation = (source, callback, keepProcessAlive) => {
   directoryWatcher.on("change", (eventType, filename) => {
     if (filename && filename !== sourceFilename) return
 
-    const type = fileSystemNodeToTypeOrNull(source)
+    const type = entryToTypeOrNull(source)
     // ignore if something else with that name gets created
     // we are only interested into files
     if (type !== "file") return
@@ -128,7 +128,7 @@ const watchFileMutation = (
   })
 
   watcher.on("change", () => {
-    const sourceType = fileSystemNodeToTypeOrNull(sourceUrl)
+    const sourceType = entryToTypeOrNull(sourceUrl)
 
     if (sourceType === null) {
       watcher.close()

package/src/{removeFileSystemNode.js → removeEntry.js}

@@ -4,11 +4,11 @@ import { Abort } from "@jsenv/abort"
 import { ensureUrlTrailingSlash } from "./internal/ensureUrlTrailingSlash.js"
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
-import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
+import { readEntryStat } from "./readEntryStat.js"
 import { readDirectory } from "./readDirectory.js"
 import { resolveUrl } from "./resolveUrl.js"
 
-export const removeFileSystemNode = async (
+export const removeEntry = async (
   source,
   {
     signal = new AbortController().signal,
@@ -26,7 +26,7 @@ export const removeFileSystemNode = async (
 
   try {
     removeOperation.throwIfAborted()
-    const sourceStats = await readFileSystemNodeStat(sourceUrl, {
+    const sourceStats = await readEntryStat(sourceUrl, {
       nullIfNotFound: true,
       followLink: false,
     })
@@ -123,7 +123,7 @@ const removeDirectory = async (
 
   const visit = async (sourceUrl) => {
     removeDirectoryOperation.throwIfAborted()
-    const sourceStats = await readFileSystemNodeStat(sourceUrl, {
+    const sourceStats = await readEntryStat(sourceUrl, {
       nullIfNotFound: true,
       followLink: false,
     })

package/src/{testFileSystemNodePermissions.js → testEntryPermissions.js}

@@ -1,4 +1,5 @@
-import { promises, constants } from "fs"
+import { promises, constants } from "node:fs"
+
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 
@@ -10,7 +11,7 @@ const {
   X_OK,
 } = constants
 
-export const testFileSystemNodePermissions = async (
+export const testEntryPermissions = async (
   source,
   {
     read = false,

package/src/urlToPathname.js

@@ -8,7 +8,12 @@ export const urlToPathname = (url) => {
 
 const ressourceToPathname = (ressource) => {
   const searchSeparatorIndex = ressource.indexOf("?")
-  return searchSeparatorIndex === -1
-    ? ressource
-    : ressource.slice(0, searchSeparatorIndex)
+  if (searchSeparatorIndex > -1) {
+    return ressource.slice(0, searchSeparatorIndex)
+  }
+  const hashIndex = ressource.indexOf("#")
+  if (hashIndex > -1) {
+    return ressource.slice(0, hashIndex)
+  }
+  return ressource
 }

package/src/urlToRelativeUrl.js

@@ -31,7 +31,6 @@ export const urlToRelativeUrl = (url, baseUrl) => {
     const urlAsString = String(url)
     return urlAsString
   }
-
   const specificPathname = pathname.slice(commonPathname.length)
   const baseSpecificPathname = basePathname.slice(commonPathname.length)
   if (baseSpecificPathname.includes("/")) {

package/src/writeDirectory.js

@@ -1,8 +1,9 @@
-import { promises } from "fs"
+import { promises } from "node:fs"
+
 import { statsToType } from "./internal/statsToType.js"
 import { assertAndNormalizeDirectoryUrl } from "./assertAndNormalizeDirectoryUrl.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
-import { readFileSystemNodeStat } from "./readFileSystemNodeStat.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
@@ -14,7 +15,7 @@ export const writeDirectory = async (
   const destinationUrl = assertAndNormalizeDirectoryUrl(destination)
   const destinationPath = urlToFileSystemPath(destinationUrl)
 
-  const destinationStats = await readFileSystemNodeStat(destinationUrl, {
+  const destinationStats = await readEntryStat(destinationUrl, {
     nullIfNotFound: true,
     followLink: false,
   })

package/src/{writeFileSystemNodeModificationTime.js → writeEntryModificationTime.js}

@@ -1,8 +1,9 @@
-import { utimes } from "fs"
+import { utimes } from "node:fs"
+
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 
-export const writeFileSystemNodeModificationTime = (source, mtime) => {
+export const writeEntryModificationTime = (source, mtime) => {
   const sourceUrl = assertAndNormalizeFileUrl(source)
   const sourcePath = urlToFileSystemPath(sourceUrl)
   const mtimeValue =

package/src/{writeFileSystemNodePermissions.js → writeEntryPermissions.js}

@@ -1,9 +1,10 @@
-import { chmod } from "fs"
+import { chmod } from "node:fs"
+
 import { permissionsToBinaryFlags } from "./internal/permissions.js"
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 
-export const writeFileSystemNodePermissions = async (source, permissions) => {
+export const writeEntryPermissions = async (source, permissions) => {
   const sourceUrl = assertAndNormalizeFileUrl(source)
   const sourcePath = urlToFileSystemPath(sourceUrl)
 

package/src/writeFile.js

@@ -1,6 +1,6 @@
-import { promises } from "fs"
+import { promises } from "node:fs"
+
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
-import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 import { ensureParentDirectories } from "./ensureParentDirectories.js"
 
 // https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_fspromises_writefile_file_data_options
@@ -8,14 +8,13 @@ const { writeFile: writeFileNode } = promises
 
 export const writeFile = async (destination, content = "") => {
   const destinationUrl = assertAndNormalizeFileUrl(destination)
-
-  const destinationPath = urlToFileSystemPath(destinationUrl)
+  const destinationUrlObject = new URL(destinationUrl)
   try {
-    await writeFileNode(destinationPath, content)
+    await writeFileNode(destinationUrlObject, content)
   } catch (error) {
     if (error.code === "ENOENT") {
       await ensureParentDirectories(destinationUrl)
-      await writeFileNode(destinationPath, content)
+      await writeFileNode(destinationUrlObject, content)
       return
     }
     throw error

package/src/writeFileSync.js

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

package/src/writeSymbolicLink.js

@@ -6,9 +6,9 @@ import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 import { resolveUrl } from "./resolveUrl.js"
 import { isFileSystemPath } from "./isFileSystemPath.js"
 import { ensureParentDirectories } from "./ensureParentDirectories.js"
-import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
+import { readEntryStat } from "./readEntryStat.js"
 import { readSymbolicLink } from "./readSymbolicLink.js"
-import { removeFileSystemNode } from "./removeFileSystemNode.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
@@ -38,7 +38,7 @@ export const writeSymbolicLink = async ({
   // In practice, if code don't specify "type" on windows, you later get EPERM errors
   // when doing operation on the symlink such as "fs.stat"
   if (isWindows && typeof type === "undefined") {
-    const toStats = await readFileSystemNodeStat(toInfo.url, {
+    const toStats = await readEntryStat(toInfo.url, {
       nullIfNotFound: true,
     })
     type = toStats && toStats.isDirectory() ? "dir" : "file"
@@ -60,7 +60,7 @@ export const writeSymbolicLink = async ({
         }
       }
       if (allowOverwrite) {
-        await removeFileSystemNode(fromUrl)
+        await removeEntry(fromUrl)
         await symlink(toInfo.value, symbolicLinkPath, type)
         return
       }

package/src/grantPermissionsOnFileSystemNode.js

@@ -1,20 +0,0 @@
-import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
-import { readFileSystemNodePermissions } from "./readFileSystemNodePermissions.js"
-import { writeFileSystemNodePermissions } from "./writeFileSystemNodePermissions.js"
-
-export const grantPermissionsOnFileSystemNode = async (
-  source,
-  { read = false, write = false, execute = false },
-) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source)
-
-  const filePermissions = await readFileSystemNodePermissions(sourceUrl)
-  await writeFileSystemNodePermissions(sourceUrl, {
-    owner: { read, write, execute },
-    group: { read, write, execute },
-    others: { read, write, execute },
-  })
-  return async () => {
-    await writeFileSystemNodePermissions(sourceUrl, filePermissions)
-  }
-}

package/src/readFileSystemNodeModificationTime.js

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