@jsenv/filesystem 2.0.0 → 2.3.0

package/main.js

@@ -22,9 +22,11 @@ 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 { copyDirectoryContent } from "./src/copyDirectoryContent.js"
 export { fileSystemPathToUrl } from "./src/fileSystemPathToUrl.js"
 export { grantPermissionsOnFileSystemNode } from "./src/grantPermissionsOnFileSystemNode.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"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/filesystem",
-  "version": "2.0.0",
+  "version": "2.3.0",
   "description": "Collection of functions to interact with filesystem in Node.js",
   "license": "MIT",
   "author": {
@@ -16,8 +16,7 @@
     "node": ">=14.17.0"
   },
   "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
+    "access": "public"
   },
   "type": "module",
   "exports": {
@@ -48,21 +47,23 @@
   },
   "dependencies": {
     "@jsenv/cancellation": "3.0.0",
-    "@jsenv/url-meta": "6.0.0"
+    "@jsenv/url-meta": "6.0.1"
   },
   "devDependencies": {
+    "@babel/core": "7.15.5",
+    "@babel/eslint-parser": "7.15.7",
     "@jsenv/assert": "2.2.7",
     "@jsenv/codecov-upload": "3.5.0",
-    "@jsenv/core": "19.6.2",
-    "@jsenv/eslint-config": "15.0.2",
+    "@jsenv/core": "20.3.0",
+    "@jsenv/eslint-config": "16.0.3",
     "@jsenv/github-release-package": "1.2.3",
-    "@jsenv/importmap-eslint-resolver": "5.1.0",
-    "@jsenv/importmap-node-module": "1.0.1",
+    "@jsenv/importmap-eslint-resolver": "5.1.2",
+    "@jsenv/importmap-node-module": "2.2.1",
     "@jsenv/package-publish": "1.6.2",
     "@jsenv/performance-impact": "1.7.0",
     "@jsenv/prettier-check-project": "5.6.1",
     "eslint": "7.32.0",
-    "eslint-plugin-import": "2.24.0",
-    "prettier": "2.3.2"
+    "eslint-plugin-import": "2.24.2",
+    "prettier": "2.4.1"
   }
 }

package/src/assertAndNormalizeDirectoryUrl.js

@@ -14,11 +14,15 @@ export const assertAndNormalizeDirectoryUrl = (value) => {
       try {
         urlString = String(new URL(value))
       } catch (e) {
-        throw new TypeError(`directoryUrl must be a valid url, received ${value}`)
+        throw new TypeError(
+          `directoryUrl must be a valid url, received ${value}`,
+        )
       }
     }
   } else {
-    throw new TypeError(`directoryUrl must be a string or an url, received ${value}`)
+    throw new TypeError(
+      `directoryUrl must be a string or an url, received ${value}`,
+    )
   }
 
   if (!urlString.startsWith("file://")) {

package/src/assertDirectoryPresence.js

@@ -15,7 +15,9 @@ export const assertDirectoryPresence = async (source) => {
   }
   if (!sourceStats.isDirectory()) {
     throw new Error(
-      `directory expected at ${sourcePath} and found ${statsToType(sourceStats)} instead`,
+      `directory expected at ${sourcePath} and found ${statsToType(
+        sourceStats,
+      )} instead`,
     )
   }
 }

package/src/assertFilePresence.js

@@ -14,6 +14,10 @@ export const assertFilePresence = async (source) => {
     throw new Error(`file not found at ${sourcePath}`)
   }
   if (!sourceStats.isFile()) {
-    throw new Error(`file expected at ${sourcePath} and found ${statsToType(sourceStats)} instead`)
+    throw new Error(
+      `file expected at ${sourcePath} and found ${statsToType(
+        sourceStats,
+      )} instead`,
+    )
   }
 }

package/src/collectDirectoryMatchReport.js

@@ -1,5 +1,9 @@
 import { createCancellationToken, createOperation } from "@jsenv/cancellation"
-import { normalizeStructuredMetaMap, urlCanContainsMetaMatching, urlToMeta } from "@jsenv/url-meta"
+import {
+  normalizeStructuredMetaMap,
+  urlCanContainsMetaMatching,
+  urlToMeta,
+} from "@jsenv/url-meta"
 
 import { ensureUrlTrailingSlash } from "./internal/ensureUrlTrailingSlash.js"
 import { assertAndNormalizeDirectoryUrl } from "./assertAndNormalizeDirectoryUrl.js"
@@ -35,7 +39,10 @@ export const collectDirectoryMatchReport = async ({
     await Promise.all(
       directoryItems.map(async (directoryItem) => {
         const directoryChildNodeUrl = `${directoryUrl}${directoryItem}`
-        const relativeUrl = urlToRelativeUrl(directoryChildNodeUrl, rootDirectoryUrl)
+        const relativeUrl = urlToRelativeUrl(
+          directoryChildNodeUrl,
+          rootDirectoryUrl,
+        )
 
         const directoryChildNodeStats = await createOperation({
           cancellationToken,
@@ -79,11 +86,19 @@ export const collectDirectoryMatchReport = async ({
             structuredMetaMap: structuredMetaMapNormalized,
           })
           if (!predicate(meta)) {
-            ignoredArray.push({ relativeUrl, meta, fileStats: directoryChildNodeStats })
+            ignoredArray.push({
+              relativeUrl,
+              meta,
+              fileStats: directoryChildNodeStats,
+            })
             return
           }
 
-          matchingArray.push({ relativeUrl, meta, fileStats: directoryChildNodeStats })
+          matchingArray.push({
+            relativeUrl,
+            meta,
+            fileStats: directoryChildNodeStats,
+          })
           return
         }
       }),

package/src/collectFiles.js

@@ -1,5 +1,9 @@
 import { createCancellationToken, createOperation } from "@jsenv/cancellation"
-import { normalizeStructuredMetaMap, urlCanContainsMetaMatching, urlToMeta } from "@jsenv/url-meta"
+import {
+  normalizeStructuredMetaMap,
+  urlCanContainsMetaMatching,
+  urlToMeta,
+} from "@jsenv/url-meta"
 
 import { assertAndNormalizeDirectoryUrl } from "./assertAndNormalizeDirectoryUrl.js"
 import { readDirectory } from "./readDirectory.js"
@@ -19,7 +23,9 @@ export const collectFiles = async ({
     throw new TypeError(`predicate must be a function, got ${predicate}`)
   }
   if (typeof matchingFileOperation !== "function") {
-    throw new TypeError(`matchingFileOperation must be a function, got ${matchingFileOperation}`)
+    throw new TypeError(
+      `matchingFileOperation must be a function, got ${matchingFileOperation}`,
+    )
   }
   const structuredMetaMapNormalized = normalizeStructuredMetaMap(
     structuredMetaMap,
@@ -75,7 +81,10 @@ export const collectFiles = async ({
           })
           if (!predicate(meta)) return
 
-          const relativeUrl = urlToRelativeUrl(directoryChildNodeUrl, rootDirectoryUrl)
+          const relativeUrl = urlToRelativeUrl(
+            directoryChildNodeUrl,
+            rootDirectoryUrl,
+          )
           const operationResult = await createOperation({
             cancellationToken,
             start: () =>
@@ -87,6 +96,7 @@ export const collectFiles = async ({
               }),
           })
           matchingFileResultArray.push({
+            url: new URL(relativeUrl, directoryUrl).href,
             relativeUrl,
             meta,
             fileStats: directoryChildNodeStats,

package/src/copyDirectoryContent.js

@@ -0,0 +1,81 @@
+import { assertAndNormalizeDirectoryUrl } from "./assertAndNormalizeDirectoryUrl.js"
+import { readFileSystemNodeStat } from "./readFileSystemNodeStat.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 { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js"
+import { statsToType } from "./internal/statsToType.js"
+
+export const copyDirectoryContent = async ({
+  from,
+  to,
+  overwrite,
+  followLink = true,
+} = {}) => {
+  const fromUrl = assertAndNormalizeDirectoryUrl(from)
+  const fromPath = urlToFileSystemPath(fromUrl)
+  let toUrl = assertAndNormalizeDirectoryUrl(to)
+  let toPath = urlToFileSystemPath(toUrl)
+
+  const sourceStats = await readFileSystemNodeStat(fromUrl, {
+    nullIfNotFound: true,
+    followLink: false,
+  })
+  if (!sourceStats) {
+    throw new Error(`no directory to copy content from at ${fromPath}`)
+  }
+  if (!sourceStats.isDirectory()) {
+    const sourceType = statsToType(sourceStats)
+    throw new Error(
+      `found a ${sourceType} instead of a directory at ${fromPath}`,
+    )
+  }
+
+  let destinationStats = await readFileSystemNodeStat(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..
+    followLink: false,
+  })
+  if (followLink && destinationStats && destinationStats.isSymbolicLink()) {
+    const linkTarget = await readSymbolicLink(toUrl)
+    toUrl = resolveUrl(linkTarget, toUrl)
+    toPath = urlToFileSystemPath(toUrl)
+    destinationStats = await readFileSystemNodeStat(toUrl, {
+      nullIfNotFound: true,
+    })
+  }
+
+  if (destinationStats === null) {
+    throw new Error(`no directory to copy content into at ${toPath}`)
+  }
+  if (!destinationStats.isDirectory()) {
+    const destinationType = statsToType(destinationStats)
+    throw new Error(
+      `destination leads to a ${destinationType} instead of a directory at ${toPath}`,
+    )
+  }
+
+  if (urlTargetsSameFileSystemPath(fromUrl, toUrl)) {
+    throw new Error(
+      `cannot copy directory content, source and destination are the same (${fromPath})`,
+    )
+  }
+
+  const directoryEntries = await readDirectory(fromUrl)
+  await Promise.all(
+    directoryEntries.map(async (directoryEntry) => {
+      const from = resolveUrl(directoryEntry, fromUrl)
+      const to = resolveUrl(directoryEntry, toUrl)
+      await copyFileSystemNode({
+        from,
+        to,
+        overwrite,
+        followLink,
+      })
+    }),
+  )
+}

package/src/copyFileSystemNode.js

@@ -54,14 +54,18 @@ export const copyFileSystemNode = async ({
     const linkTarget = await readSymbolicLink(toUrl)
     toUrl = resolveUrl(linkTarget, toUrl)
     toPath = urlToFileSystemPath(toUrl)
-    destinationStats = await readFileSystemNodeStat(toUrl, { nullIfNotFound: true })
+    destinationStats = await readFileSystemNodeStat(toUrl, {
+      nullIfNotFound: true,
+    })
   }
 
   if (urlTargetsSameFileSystemPath(fromUrl, toUrl)) {
     if (allowUseless) {
       return
     }
-    throw new Error(`cannot copy ${fromPath} because destination and source are the same`)
+    throw new Error(
+      `cannot copy ${fromPath} because destination and source are the same`,
+    )
   }
 
   if (destinationStats) {
@@ -103,16 +107,23 @@ export const copyFileSystemNode = async ({
     const fileRelativeUrl = urlToRelativeUrl(fileUrl, fromUrl)
     const fileCopyUrl = resolveUrl(fileRelativeUrl, toUrl)
 
-    await copyFileContentNaive(urlToFileSystemPath(fileUrl), urlToFileSystemPath(fileCopyUrl))
+    await copyFileContentNaive(
+      urlToFileSystemPath(fileUrl),
+      urlToFileSystemPath(fileCopyUrl),
+    )
     await copyStats(fileCopyUrl, fileStats)
   }
 
   const visitSymbolicLink = async (symbolicLinkUrl) => {
     const symbolicLinkRelativeUrl = urlToRelativeUrl(symbolicLinkUrl, fromUrl)
     const symbolicLinkTarget = await readSymbolicLink(symbolicLinkUrl)
-    const symbolicLinkTargetUrl = resolveUrl(symbolicLinkTarget, symbolicLinkUrl)
+    const symbolicLinkTargetUrl = resolveUrl(
+      symbolicLinkTarget,
+      symbolicLinkUrl,
+    )
     const linkIsRelative =
-      symbolicLinkTarget.startsWith("./") || symbolicLinkTarget.startsWith("../")
+      symbolicLinkTarget.startsWith("./") ||
+      symbolicLinkTarget.startsWith("../")
 
     let symbolicLinkCopyTarget
     if (symbolicLinkTargetUrl === fromUrl) {
@@ -120,7 +131,10 @@ export const copyFileSystemNode = async ({
     } else if (urlIsInsideOf(symbolicLinkTargetUrl, fromUrl)) {
       // symbolic link targets something inside the directory we want to copy
       // reflects it inside the copied directory structure
-      const linkCopyTargetRelative = urlToRelativeUrl(symbolicLinkTargetUrl, fromUrl)
+      const linkCopyTargetRelative = urlToRelativeUrl(
+        symbolicLinkTargetUrl,
+        fromUrl,
+      )
       symbolicLinkCopyTarget = linkIsRelative
         ? `./${linkCopyTargetRelative}`
         : resolveUrl(linkCopyTargetRelative, toUrl)
@@ -150,7 +164,10 @@ export const copyFileSystemNode = async ({
     if (preservePermissions || preserveMtime) {
       const { mode, mtimeMs } = stats
       if (preservePermissions) {
-        await writeFileSystemNodePermissions(toUrl, binaryFlagsToPermissions(mode))
+        await writeFileSystemNodePermissions(
+          toUrl,
+          binaryFlagsToPermissions(mode),
+        )
       }
       if (preserveMtime) {
         await writeFileSystemNodeModificationTime(toUrl, mtimeMs)
@@ -172,7 +189,9 @@ export const copyFileSystemNode = async ({
     await Promise.all(
       names.map(async (name) => {
         const fileSystemNodeUrl = resolveUrl(name, directoryUrl)
-        const stats = await readFileSystemNodeStat(fileSystemNodeUrl, { followLink: false })
+        const stats = await readFileSystemNodeStat(fileSystemNodeUrl, {
+          followLink: false,
+        })
         await visit(fileSystemNodeUrl, stats)
       }),
     )

package/src/ensureEmptyDirectory.js

@@ -6,7 +6,10 @@ import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
 import { removeFileSystemNode } from "./removeFileSystemNode.js"
 
 export const ensureEmptyDirectory = async (source) => {
-  const stats = await readFileSystemNodeStat(source, { nullIfNotFound: true, followLink: false })
+  const stats = await readFileSystemNodeStat(source, {
+    nullIfNotFound: true,
+    followLink: false,
+  })
   if (stats === null) {
     // if there is nothing, create a directory
     return writeDirectory(source, { allowUseless: true })

package/src/ensureParentDirectories.js

@@ -8,5 +8,8 @@ export const ensureParentDirectories = async (destination) => {
   const destinationPath = urlToFileSystemPath(destinationUrl)
   const destinationParentPath = dirname(destinationPath)
 
-  return writeDirectory(destinationParentPath, { recursive: true, allowUseless: true })
+  return writeDirectory(destinationParentPath, {
+    recursive: true,
+    allowUseless: true,
+  })
 }

package/src/ensureWindowsDriveLetter.js

@@ -45,8 +45,12 @@ export const ensureWindowsDriveLetter = (url, baseUrl) => {
   }
 
   // drive letter was lost, restore it
-  const baseUrlOrFallback = baseUrl.startsWith("file://") ? baseUrl : baseUrlFallback
-  const driveLetter = extractDriveLetter(baseUrlOrFallback.slice("file://".length))
+  const baseUrlOrFallback = baseUrl.startsWith("file://")
+    ? baseUrl
+    : baseUrlFallback
+  const driveLetter = extractDriveLetter(
+    baseUrlOrFallback.slice("file://".length),
+  )
   if (!driveLetter) {
     throw new Error(
       `drive letter expected on baseUrl but got ${baseUrl} to ensure windows drive letter on ${url}`,

package/src/internal/getCommonPathname.js

@@ -1,5 +1,8 @@
 export const getCommonPathname = (pathname, otherPathname) => {
-  const firstDifferentCharacterIndex = findFirstDifferentCharacterIndex(pathname, otherPathname)
+  const firstDifferentCharacterIndex = findFirstDifferentCharacterIndex(
+    pathname,
+    otherPathname,
+  )
 
   // pathname and otherpathname are exactly the same
   if (firstDifferentCharacterIndex === -1) {

package/src/internal/replaceBackSlashesWithSlashes.js

@@ -1 +1,2 @@
-export const replaceBackSlashesWithSlashes = (string) => string.replace(/\\/g, "/")
+export const replaceBackSlashesWithSlashes = (string) =>
+  string.replace(/\\/g, "/")

package/src/isFileSystemPath.js

@@ -1,6 +1,8 @@
 export const isFileSystemPath = (value) => {
   if (typeof value !== "string") {
-    throw new TypeError(`isFileSystemPath first arg must be a string, got ${value}`)
+    throw new TypeError(
+      `isFileSystemPath first arg must be a string, got ${value}`,
+    )
   }
 
   if (value[0] === "/") {

package/src/listFilesMatching.js

@@ -0,0 +1,34 @@
+import { collectFiles } from "./collectFiles.js"
+
+export const listFilesMatching = async (
+  patterns,
+  directoryUrl = process.cwd(),
+) => {
+  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}`,
+    )
+  }
+
+  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({
+    directoryUrl,
+    structuredMetaMap: {
+      matches: patternMap,
+    },
+    predicate: ({ matches }) => matches,
+  })
+
+  return fileDatas.map(({ url }) => url)
+}

package/src/moveDirectoryContent.js

@@ -9,7 +9,12 @@ import { moveFileSystemNode } from "./moveFileSystemNode.js"
 import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js"
 import { statsToType } from "./internal/statsToType.js"
 
-export const moveDirectoryContent = async ({ from, to, overwrite, followLink = true } = {}) => {
+export const moveDirectoryContent = async ({
+  from,
+  to,
+  overwrite,
+  followLink = true,
+} = {}) => {
   const fromUrl = assertAndNormalizeDirectoryUrl(from)
   const fromPath = urlToFileSystemPath(fromUrl)
   let toUrl = assertAndNormalizeDirectoryUrl(to)
@@ -24,7 +29,9 @@ export const moveDirectoryContent = async ({ from, to, overwrite, followLink = t
   }
   if (!sourceStats.isDirectory()) {
     const sourceType = statsToType(sourceStats)
-    throw new Error(`found a ${sourceType} instead of a directory at ${fromPath}`)
+    throw new Error(
+      `found a ${sourceType} instead of a directory at ${fromPath}`,
+    )
   }
 
   let destinationStats = await readFileSystemNodeStat(toUrl, {
@@ -37,7 +44,9 @@ export const moveDirectoryContent = async ({ from, to, overwrite, followLink = t
     const linkTarget = await readSymbolicLink(toUrl)
     toUrl = resolveUrl(linkTarget, toUrl)
     toPath = urlToFileSystemPath(toUrl)
-    destinationStats = await readFileSystemNodeStat(toUrl, { nullIfNotFound: true })
+    destinationStats = await readFileSystemNodeStat(toUrl, {
+      nullIfNotFound: true,
+    })
   }
 
   if (destinationStats === null) {
@@ -45,7 +54,9 @@ export const moveDirectoryContent = async ({ from, to, overwrite, followLink = t
   }
   if (!destinationStats.isDirectory()) {
     const destinationType = statsToType(destinationStats)
-    throw new Error(`destination leads to a ${destinationType} instead of a directory at ${toPath}`)
+    throw new Error(
+      `destination leads to a ${destinationType} instead of a directory at ${toPath}`,
+    )
   }
 
   if (urlTargetsSameFileSystemPath(fromUrl, toUrl)) {

package/src/moveFileSystemNode.js

@@ -43,14 +43,18 @@ export const moveFileSystemNode = async ({
     const linkTarget = await readSymbolicLink(toUrl)
     toUrl = resolveUrl(linkTarget, toUrl)
     toPath = urlToFileSystemPath(toUrl)
-    destinationStats = await readFileSystemNodeStat(toUrl, { nullIfNotFound: true })
+    destinationStats = await readFileSystemNodeStat(toUrl, {
+      nullIfNotFound: true,
+    })
   }
 
   if (urlTargetsSameFileSystemPath(fromUrl, toUrl)) {
     if (allowUseless) {
       return
     }
-    throw new Error(`no move needed for ${fromPath} because destination and source are the same`)
+    throw new Error(
+      `no move needed for ${fromPath} because destination and source are the same`,
+    )
   }
 
   if (destinationStats) {
@@ -86,7 +90,11 @@ export const moveFileSystemNode = async ({
   })
 }
 
-const moveNaive = (fromPath, destinationPath, { handleCrossDeviceError = null } = {}) => {
+const moveNaive = (
+  fromPath,
+  destinationPath,
+  { handleCrossDeviceError = null } = {},
+) => {
   return new Promise((resolve, reject) => {
     rename(fromPath, destinationPath, (error) => {
       if (error) {

package/src/readDirectory.js

@@ -30,12 +30,18 @@ export const readDirectory = async (url, { emfileMaxWait = 1000 } = {}) => {
   return attempt()
 }
 
-const readdirNaive = (directoryPath, { handleTooManyFilesOpenedError = null } = {}) => {
+const readdirNaive = (
+  directoryPath,
+  { handleTooManyFilesOpenedError = null } = {},
+) => {
   return new Promise((resolve, reject) => {
     readdir(directoryPath, (error, names) => {
       if (error) {
         // https://nodejs.org/dist/latest-v13.x/docs/api/errors.html#errors_common_system_errors
-        if (handleTooManyFilesOpenedError && (error.code === "EMFILE" || error.code === "ENFILE")) {
+        if (
+          handleTooManyFilesOpenedError &&
+          (error.code === "EMFILE" || error.code === "ENFILE")
+        ) {
           resolve(handleTooManyFilesOpenedError(error))
         } else {
           reject(error)

package/src/readFileSystemNodeStat.js

@@ -33,7 +33,9 @@ export const readFileSystemNodeStat = async (
       ? {
           // Windows can EPERM on stat
           handlePermissionDeniedError: async (error) => {
-            console.error(`trying to fix windows EPERM after stats on ${sourcePath}`)
+            console.error(
+              `trying to fix windows EPERM after stats on ${sourcePath}`,
+            )
 
             try {
               // unfortunately it means we mutate the permissions
@@ -64,7 +66,11 @@ export const readFileSystemNodeStat = async (
 
 const readStat = (
   sourcePath,
-  { followLink, handleNotFoundError = null, handlePermissionDeniedError = null } = {},
+  {
+    followLink,
+    handleNotFoundError = null,
+    handlePermissionDeniedError = null,
+  } = {},
 ) => {
   const nodeMethod = followLink ? stat : lstat