@jsenv/filesystem 2.6.1 → 2.7.2

package/main.js

@@ -24,6 +24,7 @@ export { ensureWindowsDriveLetter } from "./src/ensureWindowsDriveLetter.js"
 export { copyFileSystemNode } from "./src/copyFileSystemNode.js"
 export { copyDirectoryContent } from "./src/copyDirectoryContent.js"
 export { fileSystemPathToUrl } from "./src/fileSystemPathToUrl.js"
+export { getRealFileSystemUrlSync } from "./src/getRealFileSystemUrlSync.js"
 export { grantPermissionsOnFileSystemNode } from "./src/grantPermissionsOnFileSystemNode.js"
 export { isFileSystemPath } from "./src/isFileSystemPath.js"
 export { listFilesMatching } from "./src/listFilesMatching.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/filesystem",
-  "version": "2.6.1",
+  "version": "2.7.2",
   "description": "Collection of functions to interact with filesystem in Node.js",
   "license": "MIT",
   "author": {
@@ -16,7 +16,8 @@
     "node": ">=16.13.0"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
   },
   "type": "module",
   "exports": {
@@ -44,15 +45,15 @@
   },
   "devDependencies": {
     "@jsenv/assert": "2.4.1",
-    "@jsenv/core": "25.1.0",
+    "@jsenv/core": "25.2.1",
     "@jsenv/eslint-config": "16.0.9",
     "@jsenv/github-release-package": "1.2.3",
     "@jsenv/importmap-eslint-resolver": "5.2.2",
     "@jsenv/importmap-node-module": "5.1.0",
     "@jsenv/package-publish": "1.6.2",
     "@jsenv/performance-impact": "2.2.1",
-    "eslint": "8.6.0",
+    "eslint": "8.7.0",
     "eslint-plugin-import": "2.25.4",
     "prettier": "2.5.1"
   }
-}
+}

package/src/getRealFileSystemUrlSync.js

@@ -0,0 +1,59 @@
+import { readdirSync, realpathSync } from "node:fs"
+
+import { fileSystemPathToUrl } from "./fileSystemPathToUrl.js"
+import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
+
+export const getRealFileSystemUrlSync = (
+  fileUrl,
+  { followLink = true } = {},
+) => {
+  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}/`
+  }
+  let i = 0
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    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
+      }
+      throw e
+    }
+    const foundOnFilesystem = namesOnFileSystem.includes(name)
+    if (foundOnFilesystem) {
+      reconstructedFileUrl += name
+    } else {
+      const nameOnFileSystem = namesOnFileSystem.find(
+        (nameCandidate) => nameCandidate.toLowerCase() === name.toLowerCase(),
+      )
+      if (!nameOnFileSystem) {
+        return null
+      }
+      reconstructedFileUrl += nameOnFileSystem
+    }
+    if (i === parts.length) {
+      if (followLink) {
+        const realPath = realpathSync.native(
+          urlToFileSystemPath(reconstructedFileUrl),
+        )
+        return fileSystemPathToUrl(realPath)
+      }
+      return reconstructedFileUrl
+    }
+    reconstructedFileUrl += "/"
+  }
+}

package/src/internal/fileSystemNodeToTypeOrNull.js

@@ -1,5 +1,7 @@
-import { statSync } from "fs"
+import { statSync } from "node:fs"
+
 import { urlToFileSystemPath } from "../urlToFileSystemPath.js"
+
 import { statsToType } from "./statsToType.js"
 
 export const fileSystemNodeToTypeOrNull = (url) => {

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

@@ -31,16 +31,18 @@ export const writeSymbolicLink = async ({
 }) => {
   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
+  // target type and use 'file' or 'dir'"
+  // 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") {
-    // without this if you write a symbolic link without specifying the type on windows
-    // you later get EPERM when doing stat on the symlink
     const toStats = await readFileSystemNodeStat(toInfo.url, {
       nullIfNotFound: true,
     })
     type = toStats && toStats.isDirectory() ? "dir" : "file"
   }
-
   const symbolicLinkPath = urlToFileSystemPath(fromUrl)
   try {
     await symlink(toInfo.value, symbolicLinkPath, type)