@jsenv/filesystem 2.7.2 → 3.2.0

package/README.md

@@ -64,7 +64,7 @@ import { registerDirectoryLifecycle } from "@jsenv/filesystem"
 
 const directoryContentDescription = {}
 const unregister = registerDirectoryLifecycle("file:///directory/", {
-  watchDescription: {
+  watchPatterns: {
     "./**/*": true,
     "./node_modules/": false,
   },

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.2",
+  "version": "3.2.0",
   "description": "Collection of functions to interact with filesystem in Node.js",
   "license": "MIT",
   "author": {
@@ -16,8 +16,7 @@
     "node": ">=16.13.0"
   },
   "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
+    "access": "public"
   },
   "type": "module",
   "exports": {
@@ -56,4 +55,4 @@
     "eslint-plugin-import": "2.25.4",
     "prettier": "2.5.1"
   }
-}
+}

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/createWatcher.js

@@ -1,4 +1,4 @@
-import { watch, openSync, closeSync } from "fs"
+import { watch, openSync, closeSync } from "node:fs"
 
 const isWindows = process.platform === "win32"
 

package/src/internal/guard_second_call.js

@@ -0,0 +1,20 @@
+export const guardTooFastSecondCall = (
+  callback,
+  cooldownBetweenFileEvents = 40,
+) => {
+  const previousCallMsMap = new Map()
+  return (fileEvent) => {
+    const { relativeUrl } = fileEvent
+    const previousCallMs = previousCallMsMap.get(relativeUrl)
+    const nowMs = Date.now()
+    if (previousCallMs) {
+      const msEllapsed = nowMs - previousCallMs
+      if (msEllapsed < cooldownBetweenFileEvents) {
+        previousCallMsMap.delete(relativeUrl)
+        return
+      }
+    }
+    previousCallMsMap.set(relativeUrl, nowMs)
+    callback(fileEvent)
+  }
+}

package/src/internal/read_entry_info.js

@@ -0,0 +1,20 @@
+import { statSync } from "node:fs"
+
+import { statsToType } from "./statsToType.js"
+
+export const readEntryInfo = (url) => {
+  try {
+    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
+    }
+    throw e
+  }
+}

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}"`,
+  )
+}