@jsenv/filesystem 2.5.1 → 2.7.1

package/README.md

@@ -18,10 +18,13 @@ console.log(relativeUrl) // "src/file.js"
 ```js
 import { listFilesMatching } from "@jsenv/filesystem"
 
-const jsFiles = await listFilesMatching(
-  "./**/*.js",
-  new URL("./", import.meta.url),
-)
+const jsFiles = await listFilesMatching({
+  directoryUrl: new URL("./", import.meta.url),
+  patterns: {
+    "./**/*.js": true,
+    "./**/*.test.js": false,
+  },
+})
 ```
 
 ```console

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.5.1",
+  "version": "2.7.1",
   "description": "Collection of functions to interact with filesystem in Node.js",
   "license": "MIT",
   "author": {
@@ -13,57 +13,46 @@
     "url": "https://github.com/jsenv/filesystem"
   },
   "engines": {
-    "node": ">=14.17.0"
+    "node": ">=16.13.0"
   },
   "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
+    "access": "public"
   },
   "type": "module",
   "exports": {
     ".": {
-      "import": "./main.js",
-      "require": "./dist/commonjs/jsenv_filesystem.cjs"
+      "import": "./main.js"
     },
     "./*": "./*"
   },
+  "main": "./main.js",
   "files": [
-    "/dist/",
     "/src/",
     "/main.js"
   ],
   "scripts": {
-    "eslint-check": "node ./node_modules/eslint/bin/eslint.js .",
-    "generate-importmap": "node ./script/importmap/generate_importmap.mjs",
-    "measure-performances": "node ./script/performance/generate_performance_report.mjs --local",
-    "dist": "npm run build",
-    "build": "node --experimental-import-meta-resolve ./script/build/build.mjs",
+    "eslint": "node ./node_modules/eslint/bin/eslint.js .",
+    "importmap": "node ./script/importmap/importmap.mjs",
+    "performance": "node --expose-gc ./script/performance/performance.mjs --log",
     "test": "node ./script/test/test.mjs",
     "test-with-coverage": "npm run test -- --coverage",
-    "prettier-format": "node ./script/prettier/prettier_format.mjs",
-    "prettier-format-stage": "npm run prettier-format -- --staged",
-    "prettier-check": "npm run prettier-format -- --dry-run",
-    "prepublishOnly": "node ./script/publish/remove_postinstall.mjs && npm run dist",
-    "postpublish": "node ./script/publish/restore_postinstall.mjs"
+    "prettier": "prettier --write ."
   },
   "dependencies": {
-    "@jsenv/abort": "3.1.1",
-    "@jsenv/url-meta": "6.0.1"
+    "@jsenv/abort": "4.1.2",
+    "@jsenv/url-meta": "6.0.3"
   },
   "devDependencies": {
-    "@babel/core": "7.16.0",
-    "@babel/eslint-parser": "7.16.0",
-    "@jsenv/assert": "2.3.2",
-    "@jsenv/core": "23.2.2",
-    "@jsenv/eslint-config": "16.0.8",
+    "@jsenv/assert": "2.4.1",
+    "@jsenv/core": "25.2.1",
+    "@jsenv/eslint-config": "16.0.9",
     "@jsenv/github-release-package": "1.2.3",
-    "@jsenv/importmap-eslint-resolver": "5.1.2",
-    "@jsenv/importmap-node-module": "2.4.1",
+    "@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",
-    "@jsenv/prettier-check-project": "5.6.1",
-    "eslint": "7.32.0",
-    "eslint-plugin-import": "2.25.2",
-    "prettier": "2.4.1"
+    "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/listFilesMatching.js

@@ -1,33 +1,19 @@
 import { collectFiles } from "./collectFiles.js"
 
-export const listFilesMatching = async (
-  patterns,
+export const listFilesMatching = async ({
   directoryUrl = process.cwd(),
+  patterns,
   signal,
-) => {
-  if (typeof patterns === "string") {
-    patterns = [patterns]
-  } else if (Array.isArray(patterns)) {
-    throw new TypeError(
-      `patterns must be a string or an array of strings, got ${patterns}`,
-    )
+}) => {
+  if (typeof patterns !== "object" || patterns === null) {
+    throw new TypeError(`patterns must be an object, got ${patterns}`)
   }
 
-  const patternMap = {}
-  patterns.forEach((pattern, index) => {
-    if (typeof pattern !== "string") {
-      throw new TypeError(
-        `every pattern must be a string, found ${pattern} at index ${index}`,
-      )
-    }
-    patternMap[pattern] = true
-  })
-
   const fileDatas = await collectFiles({
     signal,
     directoryUrl,
     structuredMetaMap: {
-      matches: patternMap,
+      matches: patterns,
     },
     predicate: ({ matches }) => matches,
   })

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)